HRegion (Apache HBase 1.2.12 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

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`private static class`	`HRegion.BatchOperationInProgress<T>` Struct-like class that tracks the progress of a batch operation, accumulating status codes and tracking the index at which processing is proceeding.
`static class`	`HRegion.FlushResultImpl` Objects from this class are created when flushing to describe all the different states that that method ends up in.
`private static class`	`HRegion.MutationBatch`
`(package private) static class`	`HRegion.PrepareFlushResult` A result object from prepare flush cache stage
`(package private) class`	`HRegion.RegionScannerImpl` RegionScannerImpl is used to combine scanners from multiple Stores (aka column families).
`private static class`	`HRegion.ReplayBatch`
`(package private) class`	`HRegion.RowLockContext`
`static class`	`HRegion.RowLockImpl` Class used to represent a lock on a row.
`(package private) static class`	`HRegion.WriteState`

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
`private org.apache.hadoop.conf.Configuration`	`baseConf`
`private Counter`	`blockedRequestsCount`
`private long`	`blockingMemStoreSize`
`(package private) long`	`busyWaitDuration`
`(package private) Counter`	`checkAndMutateChecksFailed`
`(package private) Counter`	`checkAndMutateChecksPassed`
`(package private) AtomicBoolean`	`closed`
`private Object`	`closeLock`
`(package private) AtomicBoolean`	`closing`
`(package private) AtomicLong`	`compactionNumBytesCompacted`
`(package private) AtomicLong`	`compactionNumFilesCompacted`
`(package private) AtomicLong`	`compactionsFinished`
`private KeyValue.KVComparator`	`comparator`
`protected org.apache.hadoop.conf.Configuration`	`conf`
`private com.google.common.base.Optional<ConfigurationManager>`	`configurationManager`
`private RegionCoprocessorHost`	`coprocessorHost`
`private Map<String,com.google.protobuf.Service>`	`coprocessorServiceHandlers`
`(package private) Counter`	`dataInMemoryWithoutWAL`
`static long`	`DEEP_OVERHEAD`
`(package private) static long`	`DEFAULT_BUSY_WAIT_DURATION`
`static int`	`DEFAULT_CACHE_FLUSH_INTERVAL` Default interval for the memstore flush
`private static Durability`	`DEFAULT_DURABILITY` This is the global default value for durability.
`static long`	`DEFAULT_FLUSH_PER_CHANGES`
`private static int`	`DEFAULT_MAX_WAIT_FOR_SEQ_ID`
`(package private) static long`	`DEFAULT_ROW_PROCESSOR_TIMEOUT`
`(package private) static int`	`DEFAULT_ROWLOCK_WAIT_DURATION`
`private boolean`	`disallowWritesInRecovering` Config setting for whether to allow writes when a region is in recovering or not.
`private Durability`	`durability`
`private byte[]`	`explicitSplitPoint`
`static long`	`FIXED_OVERHEAD`
`private long`	`flushCheckInterval`
`private long`	`flushPerChanges`
`private FlushPolicy`	`flushPolicy`
`private static byte[]`	`FOR_UNIT_TESTS_ONLY` Row needed by below method.
`private HRegionFileSystem`	`fs`
`private HTableDescriptor`	`htableDescriptor`
`private boolean`	`isLoadingCfsOnDemandDefault` The default setting for whether to enable on-demand CF loading for scan requests to this region.
`private long`	`lastFlushOpSeqId` Record the sequence id of last flush operation.
`protected long`	`lastReplayedCompactionSeqId`
`protected long`	`lastReplayedOpenRegionSeqId` The sequence id of the last replayed open region event from the primary region.
`private ConcurrentMap<Store,Long>`	`lastStoreFlushTimeMap`
`static String`	`LOAD_CFS_ON_DEMAND_CONFIG_KEY`
`(package private) ReentrantReadWriteLock`	`lock`
`private ConcurrentHashMap<HashedBytes,HRegion.RowLockContext>`	`lockedRows`
`private static org.apache.commons.logging.Log`	`LOG`
`private AtomicInteger`	`majorInProgress`
`static long`	`MAX_FLUSH_PER_CHANGES` The following MAX_FLUSH_PER_CHANGES is large enough because each KeyValue has 20+ bytes overhead.
`private static String`	`MAX_WAIT_FOR_SEQ_ID_KEY`
`(package private) long`	`maxBusyWaitDuration`
`(package private) int`	`maxBusyWaitMultiplier`
`private long`	`maxFlushedSeqId` The max sequence id of flushed data on this region.
`(package private) Map<byte[],Long>`	`maxSeqIdInStores`
`private int`	`maxWaitForSeqId` Longest time we'll wait on a sequenceid.
`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
`(package private) long`	`memstoreFlushSize`
`private AtomicLong`	`memstoreSize`
`private MetricsRegion`	`metricsRegion`
`private MetricsRegionWrapperImpl`	`metricsRegionWrapper`
`private AtomicInteger`	`minorInProgress`
`private static List<Cell>`	`MOCKED_LIST` A mocked list implementation - discards all updates.
`private MultiVersionConcurrencyControl`	`mvcc`
`(package private) Counter`	`numMutationsWithoutWAL`
`private long`	`openSeqNum` The sequence ID that was encountered when this region was opened.
`private HRegion.PrepareFlushResult`	`prepareFlushResult` Saved state from replaying prepare flush cache
`(package private) Counter`	`readRequestsCount`
`private boolean`	`recovering`
`private boolean`	`regionStatsEnabled`
`private int`	`rowLockWaitDuration`
`(package private) ExecutorService`	`rowProcessorExecutor`
`(package private) long`	`rowProcessorTimeout`
`private RegionServerAccounting`	`rsAccounting`
`(package private) RegionServerServices`	`rsServices`
`private ConcurrentHashMap<RegionScanner,Long>`	`scannerReadPoints`
`private RegionSplitPolicy`	`splitPolicy`
`private boolean`	`splitRequest`
`protected Map<byte[],Store>`	`stores`
`protected List<Map>`	`storeSeqIds`
`static int`	`SYSTEM_CACHE_FLUSH_INTERVAL` Default interval for System tables memstore flush
`(package private) long`	`threadWakeFrequency`
`(package private) long`	`timestampSlop`
`private ReentrantReadWriteLock`	`updatesLock`
`private WAL`	`wal`
`(package private) Counter`	`writeRequestsCount`
`(package private) HRegion.WriteState`	`writestate`

Constructor Summary

Constructors
Constructor and Description
`HRegion(HRegionFileSystem fs, WAL wal, org.apache.hadoop.conf.Configuration confParam, HTableDescriptor 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, HRegionInfo regionInfo, HTableDescriptor htd, RegionServerServices rsServices)` Deprecated. Use other constructors.

Method Summary

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
`private void`	`addFamilyMapToWALEdit(Map<byte[],List<Cell>> familyMap, WALEdit walEdit)` Append the given map of family->edits to a WALEdit data structure.
`static void`	`addRegionToMETA(HRegion meta, HRegion r)` Inserts a new region's meta information into the passed `meta` region.
`void`	`addRegionToSnapshot(org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription desc, ForeignExceptionSnare exnSnare)` Complete taking the snapshot on the region.
`Result`	`append(Append append)`
`Result`	`append(Append mutate, long nonceGroup, long nonce)` Perform one or more append operations on a row.
`private WALKey`	`appendEmptyEdit(WAL wal)` Append a faked WALEdit in order to get a long sequence number and wal syncer will just ignore the WALEdit append later.
`private long`	`applyFamilyMapToMemstore(Map<byte[],List<Cell>> familyMap, long mvccNum, boolean isInReplay)` Atomically apply the given map of family->edits to the memstore.
`private List<Cell>`	`applyIncrementsToColumnFamily(Increment increment, byte[] columnFamilyName, List<Cell> sortedIncrements, long now, long mvccNum, List<Cell> allKVs, IsolationLevel isolation)` Apply increments to a column family.
`boolean`	`areWritesEnabled()`
`(package private) OperationStatus[]`	`batchMutate(HRegion.BatchOperationInProgress<?> batchOp)` Perform a batch of mutations.
`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.
`private Scan`	`buildScanForGetWithClosestRowBefore(Get get)`
`boolean`	`bulkLoadHFiles(Collection<Pair<byte[],String>> familyPaths, boolean assignSeqId, Region.BulkLoadListener bulkLoadListener)` Attempts to atomically load a group of hfiles.
`private static List<Tag>`	`carryForwardTags(Cell cell, List<Tag> tags)`
`private static List<Tag>`	`carryForwardTTLTag(List<Tag> tagsOrNull, Mutation mutation)`
`private static List<Tag>`	`carryForwardTTLTag(Mutation mutation)`
`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.
`private void`	`checkClassLoading()`
`private void`	`checkCompressionCodecs()`
`private void`	`checkEncryption()`
`void`	`checkFamilies(Collection<byte[]> families)` Check the collection of families for validity.
`private void`	`checkFamily(byte[] family)`
`protected void`	`checkReadOnly()`
`protected void`	`checkReadsEnabled()`
`private void`	`checkResources()`
`(package private) void`	`checkRow(byte[] row, String op)` Make sure this is a valid row for the HRegion
`byte[]`	`checkSplit()` Return the splitpoint.
`private void`	`checkTargetRegion(byte[] encodedRegionName, String exceptionMsg, Object payload)` Checks whether the given regionName is either equal to our region, or that the regionName is the primary region to our corresponding range for the secondary replica.
`void`	`checkTimestamps(Map<byte[],List<Cell>> familyMap, long now)` Check the collection of families for valid timestamps
`(package private) void`	`clearSplit()`
`Map<byte[],List<StoreFile>>`	`close()` Close down this HRegion.
`Map<byte[],List<StoreFile>>`	`close(boolean abort)` Close down this HRegion.
`private void`	`closeBulkRegionOperation()` Closes the lock.
`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)`
`boolean`	`compact(CompactionContext compaction, Store store, CompactionThroughputController throughputController, User user)`
`(package private) void`	`compactStore(byte[] family, CompactionThroughputController throughputController)` This is a helper function that compact the given store It is used by utilities and testing
`void`	`compactStores()` This is a helper function that compact all the stores synchronously It is used by utilities and testing
`static HDFSBlocksDistribution`	`computeHDFSBlocksDistribution(org.apache.hadoop.conf.Configuration conf, HTableDescriptor tableDescriptor, HRegionInfo regionInfo)` This is a helper function to compute HDFS block distribution on demand
`static HDFSBlocksDistribution`	`computeHDFSBlocksDistribution(org.apache.hadoop.conf.Configuration conf, HTableDescriptor tableDescriptor, HRegionInfo regionInfo, org.apache.hadoop.fs.Path tablePath)` This is a helper function to compute HDFS block distribution on demand
`(package private) HRegion`	`createDaughterRegionFromSplits(HRegionInfo hri)` Create a daughter region from given a temp directory with the region data.
`static HRegion`	`createHRegion(HRegionInfo info, org.apache.hadoop.fs.Path rootDir, org.apache.hadoop.conf.Configuration conf, HTableDescriptor hTableDescriptor)` Convenience method creating new HRegions.
`static HRegion`	`createHRegion(HRegionInfo info, org.apache.hadoop.fs.Path rootDir, org.apache.hadoop.conf.Configuration conf, HTableDescriptor hTableDescriptor, WAL wal)`
`static HRegion`	`createHRegion(HRegionInfo info, org.apache.hadoop.fs.Path rootDir, org.apache.hadoop.conf.Configuration conf, HTableDescriptor hTableDescriptor, WAL wal, boolean initialize)` Convenience method creating new HRegions.
`static HRegion`	`createHRegion(HRegionInfo info, org.apache.hadoop.fs.Path rootDir, org.apache.hadoop.conf.Configuration conf, HTableDescriptor hTableDescriptor, WAL wal, boolean initialize, boolean ignoreWAL)` Convenience method creating new HRegions.
`static HRegion`	`createHRegion(HRegionInfo info, org.apache.hadoop.fs.Path rootDir, org.apache.hadoop.fs.Path tableDir, org.apache.hadoop.conf.Configuration conf, HTableDescriptor hTableDescriptor, WAL wal, boolean initialize, boolean ignoreWAL)` Convenience method creating new HRegions.
`(package private) HRegion`	`createMergedRegionFromMerges(HRegionInfo mergedRegionInfo, HRegion region_b)` Create a merged region given a temp directory with the region data.
`void`	`delete(Delete delete)` Deletes the specified cells/row.
`(package private) void`	`delete(NavigableMap<byte[],List<Cell>> familyMap, Durability durability)` This is used only by unit tests.
`void`	`deregisterChildren(ConfigurationManager manager)` Needs to be called to deregister the children from the manager.
`private void`	`doBatchMutate(Mutation mutation)`
`private Map<byte[],List<StoreFile>>`	`doClose(boolean abort, MonitoredTask status)`
`private long`	`doDropStoreMemstoreContentsForSeqId(Store s, long currentSeqId)`
`private List<Cell>`	`doGet(Store store, byte[] row, Map.Entry<byte[],List<Cell>> family, TimeRange tr)` Run a Get against passed in `store` on passed `row`, etc.
`private Result`	`doIncrement(Increment increment, long nonceGroup, long nonce)`
`private long`	`doMiniBatchMutation(HRegion.BatchOperationInProgress<?> batchOp)`
`private void`	`doPreMutationHook(HRegion.BatchOperationInProgress<?> batchOp)`
`private void`	`doProcessRowWithTimeout(RowProcessor<?,?> processor, long now, HRegion region, List<Mutation> mutations, WALEdit walEdit, long timeout)`
`protected void`	`doRegionCompactionPrep()`
`private void`	`dropMemstoreContents()`
`private long`	`dropMemstoreContentsForSeqId(long seqId, Store store)` Drops the memstore contents after replaying a flush descriptor or region open event replay if the memstore edits have seqNums smaller than the given seq id
`private void`	`dropPrepareFlushIfPossible()` If all stores ended up dropping their snapshots, we can safely drop the prepareFlushResult
`boolean`	`equals(Object o)`
`com.google.protobuf.Message`	`execService(com.google.protobuf.RpcController controller, org.apache.hadoop.hbase.protobuf.generated.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.
`(package private) void`	`forceSplit(byte[] sp)`
`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.
`(package private) org.apache.hadoop.conf.Configuration`	`getBaseConf()` A split takes the config from the parent region & passes it to the daughter region's constructor.
`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.
`org.apache.hadoop.hbase.protobuf.generated.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.
`(package private) byte[]`	`getExplicitSplitPoint()`
`org.apache.hadoop.fs.FileSystem`	`getFilesystem()`
`HDFSBlocksDistribution`	`getHDFSBlocksDistribution()`
`private List<Cell>`	`getIncrementCurrentValue(Increment increment, byte[] columnFamily, List<Cell> increments, IsolationLevel isolation)` Do a specific Get on passed `columnFamily` and column qualifiers from `incrementCoordinates` only.
`long`	`getLargestHStoreSize()`
`ConcurrentHashMap<HashedBytes,HRegion.RowLockContext>`	`getLockedRows()`
`private static long`	`getLongValue(Cell cell)`
`long`	`getMaxFlushedSeqId()`
`Map<byte[],Long>`	`getMaxStoreSeqId()`
`long`	`getMemstoreSize()`
`MetricsRegion`	`getMetrics()`
`MultiVersionConcurrencyControl`	`getMVCC()`
`private static Cell`	`getNewCell(byte[] row, long ts, Cell cell, Cell oldCell, byte[] tagBytes)`
`private static Cell`	`getNewCell(Mutation mutate, Cell cell)`
`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)`
`(package private) static ThreadPoolExecutor`	`getOpenAndCloseThreadPool(int maxThreads, String threadNamePrefix)`
`long`	`getOpenSeqNum()`
`(package private) HRegion.PrepareFlushResult`	`getPrepareFlushResult()`
`long`	`getReadpoint(IsolationLevel isolationLevel)`
`long`	`getReadRequestsCount()`
`static org.apache.hadoop.fs.Path`	`getRegionDir(org.apache.hadoop.fs.Path rootdir, HRegionInfo info)` Deprecated. For tests only; to be removed.
`static org.apache.hadoop.fs.Path`	`getRegionDir(org.apache.hadoop.fs.Path tabledir, String name)` Deprecated. For tests only; to be removed.
`HRegionFileSystem`	`getRegionFileSystem()`
`HRegionInfo`	`getRegionInfo()`
`(package private) RegionServerServices`	`getRegionServerServices()`
`org.apache.hadoop.hbase.protobuf.generated.ClientProtos.RegionLoadStats`	`getRegionStats()`
`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.
`Region.RowLock`	`getRowLock(byte[] row, boolean readLock, boolean waitForLock)` Get a row lock for the specified row.
`RegionScanner`	`getScanner(Scan scan)` Return an iterator that scans over the HRegion, returning the indicated columns and rows specified by the `Scan`.
`RegionScanner`	`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`	`getSequenceId()` Do not change this sequence id.
`long`	`getSmallestReadPoint()`
`RegionSplitPolicy`	`getSplitPolicy()`
`Store`	`getStore(byte[] column)` Return the Store for the given family
`private Store`	`getStore(Cell cell)` Return HStore instance.
`List<String>`	`getStoreFileList(byte[][] columns)`
`protected ThreadPoolExecutor`	`getStoreFileOpenAndCloseThreadPool(String threadNamePrefix)`
`private NavigableMap<byte[],List<org.apache.hadoop.fs.Path>>`	`getStoreFiles()`
`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()`
`private static boolean`	`hasMultipleColumnFamilies(Collection<Pair<byte[],String>> familyPaths)` Determines whether multiple column families are present Precondition: familyPaths is not null
`boolean`	`hasReferences()`
`long`	`heapSize()`
`Result`	`increment(Increment increment)`
`Result`	`increment(Increment mutation, long nonceGroup, long nonce)` Perform one or more increment operations on a row.
`long`	`initialize()` Deprecated. use HRegion.createHRegion() or HRegion.openHRegion()
`private long`	`initialize(CancelableProgressable reporter)` Initialize this region.
`private long`	`initializeRegionInternals(CancelableProgressable reporter, MonitoredTask status)`
`private long`	`initializeStores(CancelableProgressable reporter, MonitoredTask status)` Open all Stores.
`private void`	`initializeWarmup(CancelableProgressable reporter)`
`protected HStore`	`instantiateHStore(HColumnDescriptor family)`
`protected RegionScanner`	`instantiateRegionScanner(Scan scan, List<KeyValueScanner> additionalScanners)`
`private Region.FlushResult`	`internalFlushcache(Collection<Store> storesToFlush, MonitoredTask status, boolean writeFlushWalMarker)` Flushing given stores.
`private Region.FlushResult`	`internalFlushcache(MonitoredTask status)` Flushing all stores.
`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, HRegion.PrepareFlushResult prepareResult, Collection<Store> storesToFlush)`
`protected HRegion.PrepareFlushResult`	`internalPrepareFlushCache(WAL wal, long myseqid, Collection<Store> storesToFlush, MonitoredTask status, boolean writeFlushWalMarker)`
`private boolean`	`isAllFamilies(Collection<Store> families)`
`boolean`	`isAvailable()`
`boolean`	`isClosed()`
`boolean`	`isClosing()`
`private boolean`	`isFlushSize(long size)`
`boolean`	`isLoadingCfsOnDemandDefault()`
`boolean`	`isMergeable()`
`boolean`	`isReadOnly()`
`boolean`	`isRecovering()`
`boolean`	`isSplittable()`
`private static boolean`	`isZeroLengthThenDelete(org.apache.hadoop.fs.FileSystem fs, org.apache.hadoop.fs.Path p)`
`private void`	`lock(Lock lock)`
`private void`	`lock(Lock lock, int multiplier)` Try to acquire a lock.
`private void`	`logRegionFiles()`
`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.
`(package private) static HRegion`	`newHRegion(org.apache.hadoop.fs.Path tableDir, WAL wal, org.apache.hadoop.fs.FileSystem fs, org.apache.hadoop.conf.Configuration conf, HRegionInfo regionInfo, HTableDescriptor 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)` 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(org.apache.hadoop.conf.Configuration conf, org.apache.hadoop.fs.FileSystem fs, org.apache.hadoop.fs.Path rootDir, HRegionInfo info, HTableDescriptor 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, HRegionInfo info, HTableDescriptor htd, WAL wal, RegionServerServices rsServices, CancelableProgressable reporter)` Open a Region.
`static HRegion`	`openHRegion(org.apache.hadoop.conf.Configuration conf, org.apache.hadoop.fs.FileSystem fs, org.apache.hadoop.fs.Path rootDir, org.apache.hadoop.fs.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, org.apache.hadoop.conf.Configuration conf)` Open a Region.
`static HRegion`	`openHRegion(HRegionInfo info, HTableDescriptor htd, WAL wal, org.apache.hadoop.conf.Configuration conf, RegionServerServices rsServices, CancelableProgressable reporter)` Open a Region.
`static HRegion`	`openHRegion(org.apache.hadoop.fs.Path rootDir, HRegionInfo info, HTableDescriptor htd, WAL wal, org.apache.hadoop.conf.Configuration conf)` Open a Region.
`static HRegion`	`openHRegion(org.apache.hadoop.fs.Path rootDir, HRegionInfo info, HTableDescriptor htd, WAL wal, org.apache.hadoop.conf.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.
`private static void`	`printUsageAndExit(String message)`
`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.
`private static void`	`processTable(org.apache.hadoop.fs.FileSystem fs, org.apache.hadoop.fs.Path p, WALFactory walFactory, org.apache.hadoop.conf.Configuration c, boolean majorCompact)`
`private void`	`put(byte[] row, byte[] family, List<Cell> edits)` Add updates first to the wal and then add values to memstore.
`void`	`put(Put put)` Puts some data in the table.
`private void`	`recordMutationWithoutWal(Map<byte[],List<Cell>> familyMap)` Update counters for number of puts without wal and the size of possible data loss.
`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)` Needs to be called to register the children to the 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`	`releaseRowLocks(List<Region.RowLock> rowLocks)` If the given list of row locks is not null, releases all locks.
`private void`	`removeNonExistentColumnFamilyForReplay(Map<byte[],List<Cell>> familyMap)` During replay, there could exist column families which are removed between region server failure and replay
`private void`	`replayFlushInStores(org.apache.hadoop.hbase.protobuf.generated.WALProtos.FlushDescriptor flush, HRegion.PrepareFlushResult prepareFlushResult, boolean dropMemstoreSnapshot)` Replays the given flush descriptor by opening the flush files in stores and dropping the memstore snapshots if requested.
`private long`	`replayRecoveredEdits(org.apache.hadoop.fs.Path edits, Map<byte[],Long> maxSeqIdInStores, CancelableProgressable reporter)`
`protected long`	`replayRecoveredEditsIfAny(org.apache.hadoop.fs.Path regiondir, Map<byte[],Long> maxSeqIdInStores, CancelableProgressable reporter, MonitoredTask status)` Read the edits put under this region by wal splitting process.
`(package private) void`	`replayWALBulkLoadEventMarker(org.apache.hadoop.hbase.protobuf.generated.WALProtos.BulkLoadDescriptor bulkLoadEvent)`
`(package private) void`	`replayWALCompactionMarker(org.apache.hadoop.hbase.protobuf.generated.WALProtos.CompactionDescriptor compaction, boolean pickCompactionFiles, boolean removeFiles, long replaySeqId)` Call to complete a compaction.
`private void`	`replayWALFlushAbortMarker(org.apache.hadoop.hbase.protobuf.generated.WALProtos.FlushDescriptor flush)`
`private void`	`replayWALFlushCannotFlushMarker(org.apache.hadoop.hbase.protobuf.generated.WALProtos.FlushDescriptor flush, long replaySeqId)`
`(package private) void`	`replayWALFlushCommitMarker(org.apache.hadoop.hbase.protobuf.generated.WALProtos.FlushDescriptor flush)`
`(package private) void`	`replayWALFlushMarker(org.apache.hadoop.hbase.protobuf.generated.WALProtos.FlushDescriptor flush, long replaySeqId)`
`(package private) HRegion.PrepareFlushResult`	`replayWALFlushStartMarker(org.apache.hadoop.hbase.protobuf.generated.WALProtos.FlushDescriptor flush)` Replay the flush marker from primary region by creating a corresponding snapshot of the store memstores, only if the memstores do not have a higher seqId from an earlier wal edit (because the events may be coming out of order).
`(package private) void`	`replayWALRegionEventMarker(org.apache.hadoop.hbase.protobuf.generated.WALProtos.RegionEventDescriptor regionEvent)`
`void`	`reportCompactionRequestEnd(boolean isMajor, int numFiles, long filesSizeCompacted)`
`void`	`reportCompactionRequestStart(boolean isMajor)`
`private void`	`requestFlush()`
`protected boolean`	`restoreEdit(Store s, Cell cell)` Used by tests
`(package private) void`	`rewriteCellTags(Map<byte[],List<Cell>> familyMap, Mutation m)` Possibly rewrite incoming cell tags.
`private void`	`rollbackMemstore(List<Cell> memstoreCells)` Remove all the keys listed in the map from the memstore.
`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.
`(package private) org.apache.hadoop.hbase.protobuf.generated.ClusterStatusProtos.RegionLoad.Builder`	`setCompleteSequenceId(org.apache.hadoop.hbase.protobuf.generated.ClusterStatusProtos.RegionLoad.Builder regionLoadBldr)`
`void`	`setCoprocessorHost(RegionCoprocessorHost coprocessorHost)`
`(package private) void`	`setHTableSpecificConf()`
`void`	`setReadsEnabled(boolean readsEnabled)`
`void`	`setRecovering(boolean newState)` Reset recovering state of current region
`(package private) boolean`	`shouldFlush(StringBuffer whyFlush)` Should the memstore be flushed now
`(package private) boolean`	`shouldFlushStore(Store store)` Should the store be flushed because it is old enough.
`(package private) boolean`	`shouldForceSplit()`
`private boolean`	`shouldSyncWAL()` Check whether we should sync the wal from the table's durability settings
`private static List<Cell>`	`sort(List<Cell> cells, Comparator<Cell> comparator)`
`private void`	`startBulkRegionOperation(boolean writeLockNeeded)` This method needs to be called before any public call that reads or modifies stores in bulk.
`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.
`private void`	`syncOrDefer(long txid, Durability durability)` Calls sync with the given transaction ID if the region's table is not deferring it.
`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.
`(package private) void`	`updateDeleteLatestVersionTimeStamp(Cell cell, Get get, int count, byte[] byteNow)`
`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`	`waitForFlushes()`
`void`	`waitForFlushesAndCompactions()` Wait for all current flushes and compactions of the region to complete
`static void`	`warmupHRegion(HRegionInfo info, HTableDescriptor htd, WAL wal, org.apache.hadoop.conf.Configuration conf, RegionServerServices rsServices, CancelableProgressable reporter)`
`private boolean`	`worthPreFlushing()`
`private boolean`	`writeFlushRequestMarkerToWAL(WAL wal, boolean writeFlushWalMarker)` Writes a marker to WAL indicating a flush is requested but cannot be complete due to various reasons.
`private void`	`writeRegionCloseMarker(WAL wal)`
`private void`	`writeRegionOpenMarker(WAL wal, long openSeqId)`

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

- Field Detail
  - LOG
```
private static final org.apache.commons.logging.Log LOG
```
  - LOAD_CFS_ON_DEMAND_CONFIG_KEY
```
public static final String LOAD_CFS_ON_DEMAND_CONFIG_KEY
```
    See Also:
    Constant Field Values
  - maxWaitForSeqId
```
private final int maxWaitForSeqId
```
    Longest time we'll wait on a sequenceid. Sequenceid comes up out of the WAL subsystem. WAL subsystem can go bad or a test might use it without cleaning up previous usage properly; generally, a WAL roll is needed. The timeout is for a latch in WALKey. There is no global accounting of outstanding WALKeys; intentionally to avoid contention, but it makes it so if an abort or problem, we could be stuck waiting on the WALKey latch. Revisit.
  - MAX_WAIT_FOR_SEQ_ID_KEY
```
private static final String MAX_WAIT_FOR_SEQ_ID_KEY
```
    See Also:
    Constant Field Values
  - DEFAULT_MAX_WAIT_FOR_SEQ_ID
```
private static final int DEFAULT_MAX_WAIT_FOR_SEQ_ID
```
    See Also:
    Constant Field Values
  - DEFAULT_DURABILITY
```
private static final Durability DEFAULT_DURABILITY
```
    This is the global default value for durability. All tables/mutations not defining a durability or using USE_DEFAULT will default to this value.
  - closed
```
final AtomicBoolean closed
```
  - closing
```
final AtomicBoolean closing
```
  - maxFlushedSeqId
```
private volatile long maxFlushedSeqId
```
    The max sequence id of flushed data on this region. There is no edit in memory that is less that this sequence id.
  - lastFlushOpSeqId
```
private volatile long lastFlushOpSeqId
```
    Record the sequence id of last flush operation. Can be in advance of maxFlushedSeqId when flushing a single column family. In this case, maxFlushedSeqId will be older than the oldest edit in memory.
  - 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
```
  - storeSeqIds
```
protected List<Map> storeSeqIds
```
  - lockedRows
```
private final ConcurrentHashMap<HashedBytes,HRegion.RowLockContext> lockedRows
```
  - stores
```
protected final Map<byte[],Store> stores
```
  - coprocessorServiceHandlers
```
private Map<String,com.google.protobuf.Service> coprocessorServiceHandlers
```
  - memstoreSize
```
private final AtomicLong memstoreSize
```
  - numMutationsWithoutWAL
```
final Counter numMutationsWithoutWAL
```
  - dataInMemoryWithoutWAL
```
final Counter dataInMemoryWithoutWAL
```
  - checkAndMutateChecksPassed
```
final Counter checkAndMutateChecksPassed
```
  - checkAndMutateChecksFailed
```
final Counter checkAndMutateChecksFailed
```
  - readRequestsCount
```
final Counter readRequestsCount
```
  - writeRequestsCount
```
final Counter writeRequestsCount
```
  - blockedRequestsCount
```
private final Counter blockedRequestsCount
```
  - compactionsFinished
```
final AtomicLong compactionsFinished
```
  - compactionNumFilesCompacted
```
final AtomicLong compactionNumFilesCompacted
```
  - compactionNumBytesCompacted
```
final AtomicLong compactionNumBytesCompacted
```
  - wal
```
private final WAL wal
```
  - fs
```
private final HRegionFileSystem fs
```
  - conf
```
protected final org.apache.hadoop.conf.Configuration conf
```
  - baseConf
```
private final org.apache.hadoop.conf.Configuration baseConf
```
  - comparator
```
private final KeyValue.KVComparator comparator
```
  - rowLockWaitDuration
```
private final int rowLockWaitDuration
```
  - DEFAULT_ROWLOCK_WAIT_DURATION
```
static final int DEFAULT_ROWLOCK_WAIT_DURATION
```
    See Also:
    Constant Field Values
  - busyWaitDuration
```
final long busyWaitDuration
```
  - DEFAULT_BUSY_WAIT_DURATION
```
static final long DEFAULT_BUSY_WAIT_DURATION
```
    See Also:
    Constant Field Values
  - maxBusyWaitMultiplier
```
final int maxBusyWaitMultiplier
```
  - maxBusyWaitDuration
```
final long maxBusyWaitDuration
```
  - DEFAULT_ROW_PROCESSOR_TIMEOUT
```
static final long DEFAULT_ROW_PROCESSOR_TIMEOUT
```
    See Also:
    Constant Field Values
  - rowProcessorExecutor
```
final ExecutorService rowProcessorExecutor
```
  - scannerReadPoints
```
private final ConcurrentHashMap<RegionScanner,Long> scannerReadPoints
```
  - openSeqNum
```
private long openSeqNum
```
    The sequence ID that was encountered when this region was opened.
  - isLoadingCfsOnDemandDefault
```
private boolean isLoadingCfsOnDemandDefault
```
    The default setting for whether to enable on-demand CF loading for scan requests to this region. Requests can override it.
  - majorInProgress
```
private final AtomicInteger majorInProgress
```
  - minorInProgress
```
private final AtomicInteger minorInProgress
```
  - maxSeqIdInStores
```
Map<byte[],Long> maxSeqIdInStores
```
  - prepareFlushResult
```
private HRegion.PrepareFlushResult prepareFlushResult
```
    Saved state from replaying prepare flush cache
  - disallowWritesInRecovering
```
private boolean disallowWritesInRecovering
```
    Config setting for whether to allow writes when a region is in recovering or not.
  - recovering
```
private volatile boolean recovering
```
  - configurationManager
```
private volatile com.google.common.base.Optional<ConfigurationManager> configurationManager
```
  - writestate
```
final HRegion.WriteState writestate
```
  - memstoreFlushSize
```
long memstoreFlushSize
```
  - timestampSlop
```
final long timestampSlop
```
  - rowProcessorTimeout
```
final long rowProcessorTimeout
```
  - lastStoreFlushTimeMap
```
private final ConcurrentMap<Store,Long> lastStoreFlushTimeMap
```
  - rsServices
```
final RegionServerServices rsServices
```
  - rsAccounting
```
private RegionServerAccounting rsAccounting
```
  - flushCheckInterval
```
private long flushCheckInterval
```
  - flushPerChanges
```
private long flushPerChanges
```
  - blockingMemStoreSize
```
private long blockingMemStoreSize
```
  - threadWakeFrequency
```
final long threadWakeFrequency
```
  - lock
```
final ReentrantReadWriteLock lock
```
  - updatesLock
```
private final ReentrantReadWriteLock updatesLock
```
  - splitRequest
```
private boolean splitRequest
```
  - explicitSplitPoint
```
private byte[] explicitSplitPoint
```
  - mvcc
```
private final MultiVersionConcurrencyControl mvcc
```
  - coprocessorHost
```
private RegionCoprocessorHost coprocessorHost
```
  - htableDescriptor
```
private HTableDescriptor htableDescriptor
```
  - splitPolicy
```
private RegionSplitPolicy splitPolicy
```
  - flushPolicy
```
private FlushPolicy flushPolicy
```
  - metricsRegion
```
private final MetricsRegion metricsRegion
```
  - metricsRegionWrapper
```
private final MetricsRegionWrapperImpl metricsRegionWrapper
```
  - durability
```
private final Durability durability
```
  - regionStatsEnabled
```
private final boolean regionStatsEnabled
```
  - closeLock
```
private final Object closeLock
```
  - 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
  - FOR_UNIT_TESTS_ONLY
```
private static final byte[] FOR_UNIT_TESTS_ONLY
```
    Row needed by below method.
  - FIXED_OVERHEAD
```
public static final long FIXED_OVERHEAD
```
  - DEEP_OVERHEAD
```
public static final long DEEP_OVERHEAD
```
  - MOCKED_LIST
```
private static final List<Cell> MOCKED_LIST
```
    A mocked list implementation - discards all updates.
- 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,
                  HRegionInfo regionInfo,
                  HTableDescriptor 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.HRegionInfo, org.apache.hadoop.fs.Path, org.apache.hadoop.conf.Configuration, org.apache.hadoop.hbase.HTableDescriptor) or openHRegion(org.apache.hadoop.hbase.HRegionInfo, org.apache.hadoop.hbase.HTableDescriptor, 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 - - 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,
       org.apache.hadoop.conf.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, org.apache.hadoop.fs.Path, org.apache.hadoop.conf.Configuration, org.apache.hadoop.hbase.HTableDescriptor) or openHRegion(org.apache.hadoop.hbase.HRegionInfo, org.apache.hadoop.hbase.HTableDescriptor, 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
  - 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.
  - setHTableSpecificConf
```
void setHTableSpecificConf()
```
  - 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
  - initialize
```
private long initialize(CancelableProgressable reporter)
                 throws IOException
```
    Initialize this region.
    
    Parameters:
    reporter - Tickle every so often if initialize is taking a while.
    
    Returns:
    What the next sequence (edit) id should be.
    
    Throws:
    
    IOException - e
  - initializeRegionInternals
```
private long initializeRegionInternals(CancelableProgressable reporter,
                             MonitoredTask status)
                                throws IOException
```
    Throws:
    
    IOException
  - initializeStores
```
private long initializeStores(CancelableProgressable reporter,
                    MonitoredTask status)
                       throws IOException
```
    Open all Stores.
    
    Parameters:
    reporter -
    status -
    
    Returns:
    Highest sequenceId found out in a Store.
    
    Throws:
    
    IOException
  - initializeWarmup
```
private void initializeWarmup(CancelableProgressable reporter)
                       throws IOException
```
    Throws:
    
    IOException
  - getStoreFiles
```
private NavigableMap<byte[],List<org.apache.hadoop.fs.Path>> getStoreFiles()
```
    Returns:
    Map of StoreFiles by column family
  - writeRegionOpenMarker
```
private void writeRegionOpenMarker(WAL wal,
                         long openSeqId)
                            throws IOException
```
    Throws:
    
    IOException
  - writeRegionCloseMarker
```
private void writeRegionCloseMarker(WAL wal)
                             throws IOException
```
    Throws:
    
    IOException
  - 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(org.apache.hadoop.conf.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(org.apache.hadoop.conf.Configuration conf,
                                                   HTableDescriptor tableDescriptor,
                                                   HRegionInfo 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 - 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
  - getRegionServerServices
```
RegionServerServices getRegionServerServices()
```
    Returns:
    Instance of RegionServerServices used by this HRegion. Can be null.
  - 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 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)
```
    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.
  - doClose
```
private Map<byte[],List<StoreFile>> doClose(boolean abort,
                                  MonitoredTask status)
                                     throws IOException
```
    Throws:
    
    IOException
  - 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
  - waitForFlushes
```
public void waitForFlushes()
```
  - getStoreOpenAndCloseThreadPool
```
protected ThreadPoolExecutor getStoreOpenAndCloseThreadPool(String threadNamePrefix)
```
  - getStoreFileOpenAndCloseThreadPool
```
protected ThreadPoolExecutor getStoreFileOpenAndCloseThreadPool(String threadNamePrefix)
```
  - getOpenAndCloseThreadPool
```
static ThreadPoolExecutor getOpenAndCloseThreadPool(int maxThreads,
                                           String threadNamePrefix)
```
  - worthPreFlushing
```
private boolean worthPreFlushing()
```
    Returns:
    True if its worth doing a flush before we put up the close flag.
  - 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
  - getBaseConf
```
org.apache.hadoop.conf.Configuration getBaseConf()
```
    A split takes the config from the parent region & passes it to the daughter region's constructor. If 'conf' was passed, you would end up using the HTD of the parent region in addition to the new daughter HTD. Pass 'baseConf' to the daughter regions to avoid this tricky dedupe problem.
    
    Returns:
    Configuration object
  - 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
  - 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
  - setCompleteSequenceId
```
org.apache.hadoop.hbase.protobuf.generated.ClusterStatusProtos.RegionLoad.Builder setCompleteSequenceId(org.apache.hadoop.hbase.protobuf.generated.ClusterStatusProtos.RegionLoad.Builder regionLoadBldr)
```
  - 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
  - compactStore
```
void compactStore(byte[] family,
                CompactionThroughputController throughputController)
            throws IOException
```
    This is a helper function that compact the given store It is used by utilities and testing
    
    Throws:
    
    IOException - e
  - compact
```
public boolean compact(CompactionContext compaction,
              Store store,
              CompactionThroughputController throughputController)
                throws IOException
```
    Throws:
    
    IOException
  - compact
```
public boolean compact(CompactionContext compaction,
              Store store,
              CompactionThroughputController throughputController,
              User user)
                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 because a snapshot was not properly persisted.
  - 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.
  - shouldFlushStore
```
boolean shouldFlushStore(Store store)
```
    Should the store be flushed because it is old enough.
    Every FlushPolicy should call this to determine whether a store is old enough to flush(except that you always flush all stores). Otherwise the #shouldFlush() method will always returns true which will make a lot of flush requests.
  - shouldFlush
```
boolean shouldFlush(StringBuffer whyFlush)
```
    Should the memstore be flushed now
  - internalFlushcache
```
private Region.FlushResult internalFlushcache(MonitoredTask status)
                                       throws IOException
```
    Flushing all stores.
    
    Throws:
    
    IOException
    See Also:
    internalFlushcache(Collection, MonitoredTask, boolean)
  - internalFlushcache
```
private Region.FlushResult internalFlushcache(Collection<Store> storesToFlush,
                                    MonitoredTask status,
                                    boolean writeFlushWalMarker)
                                       throws IOException
```
    Flushing given stores.
    
    Throws:
    
    IOException
    See Also:
    internalFlushcache(WAL, long, Collection, MonitoredTask, boolean)
  - 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 HRegion.PrepareFlushResult internalPrepareFlushCache(WAL wal,
                                                   long myseqid,
                                                   Collection<Store> storesToFlush,
                                                   MonitoredTask status,
                                                   boolean writeFlushWalMarker)
                                                        throws IOException
```
    Throws:
    
    IOException
  - isAllFamilies
```
private boolean isAllFamilies(Collection<Store> families)
```
    Parameters:
    families -
    
    Returns:
    True if passed Set is all families in the region.
  - writeFlushRequestMarkerToWAL
```
private boolean writeFlushRequestMarkerToWAL(WAL wal,
                                   boolean writeFlushWalMarker)
```
    Writes a marker to WAL indicating a flush is requested but cannot be complete due to various reasons. Ignores exceptions from WAL. Returns whether the write succeeded.
    
    Parameters:
    wal -
    
    Returns:
    whether WAL write was successful
  - internalFlushCacheAndCommit
```
protected Region.FlushResult internalFlushCacheAndCommit(WAL wal,
                                             MonitoredTask status,
                                             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
```
public RegionScanner 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
    
    Returns:
    RegionScanner
    
    Throws:
    
    IOException - read exceptions
  - 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
  - delete
```
void delete(NavigableMap<byte[],List<Cell>> familyMap,
          Durability durability)
      throws IOException
```
    This is used only by unit tests. Not required to be a public API.
    
    Parameters:
    familyMap - map of family to edits for the given family.
    
    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
  - updateDeleteLatestVersionTimeStamp
```
void updateDeleteLatestVersionTimeStamp(Cell cell,
                                      Get get,
                                      int count,
                                      byte[] byteNow)
                                  throws IOException
```
    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
  - batchMutate
```
OperationStatus[] batchMutate(HRegion.BatchOperationInProgress<?> batchOp)
                        throws IOException
```
    Perform a batch of mutations. It supports only Put and Delete mutations and will ignore other types passed.
    
    Parameters:
    batchOp - contains the list of mutations
    
    Returns:
    an array of OperationStatus which internally contains the OperationStatusCode and the exceptionMessage if any.
    
    Throws:
    
    IOException
  - doPreMutationHook
```
private void doPreMutationHook(HRegion.BatchOperationInProgress<?> batchOp)
                        throws IOException
```
    Throws:
    
    IOException
  - doMiniBatchMutation
```
private long doMiniBatchMutation(HRegion.BatchOperationInProgress<?> batchOp)
                          throws IOException
```
    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
  - doBatchMutate
```
private void doBatchMutate(Mutation mutation)
                    throws IOException
```
    Throws:
    
    IOException
  - addRegionToSnapshot
```
public void addRegionToSnapshot(org.apache.hadoop.hbase.protobuf.generated.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
  - rewriteCellTags
```
void rewriteCellTags(Map<byte[],List<Cell>> familyMap,
                   Mutation m)
```
    Possibly rewrite incoming cell tags.
  - checkResources
```
private void checkResources()
                     throws RegionTooBusyException
```
    Throws:
    
    RegionTooBusyException
  - 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)
```
  - put
```
private void put(byte[] row,
       byte[] family,
       List<Cell> edits)
          throws IOException
```
    Add updates first to the wal and then add values to memstore. Warning: Assumption is caller has lock on passed in row.
    
    Parameters:
    edits - Cell updates by column
    
    Throws:
    
    IOException
  - applyFamilyMapToMemstore
```
private long applyFamilyMapToMemstore(Map<byte[],List<Cell>> familyMap,
                            long mvccNum,
                            boolean isInReplay)
                               throws IOException
```
    Atomically apply the given map of family->edits to the memstore. This handles the consistency control on its own, but the caller should already have locked updatesLock.readLock(). This also does not check the families for validity.
    
    Parameters:
    familyMap - Map of kvs per family
    localizedWriteEntry - The WriteEntry of the MVCC for this transaction. If null, then this method internally creates a mvcc transaction.
    output - newly added KVs into memstore
    isInReplay - true when adding replayed KVs into memstore
    
    Returns:
    the additional memory usage of the memstore caused by the new entries.
    
    Throws:
    
    IOException
  - rollbackMemstore
```
private void rollbackMemstore(List<Cell> memstoreCells)
```
    Remove all the keys listed in the map from the memstore. This method is called when a Put/Delete has updated memstore but subsequently fails to update the wal. This method is then invoked to rollback the memstore.
  - 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
  - removeNonExistentColumnFamilyForReplay
```
private void removeNonExistentColumnFamilyForReplay(Map<byte[],List<Cell>> familyMap)
```
    During replay, there could exist column families which are removed between region server failure and replay
  - 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
  - addFamilyMapToWALEdit
```
private void addFamilyMapToWALEdit(Map<byte[],List<Cell>> familyMap,
                         WALEdit walEdit)
```
    Append the given map of family->edits to a WALEdit data structure. This does not write to the WAL itself.
    
    Parameters:
    familyMap - map of family->edits
    walEdit - the destination entry to append into
  - requestFlush
```
private void requestFlush()
```
  - isFlushSize
```
private boolean isFlushSize(long size)
```
  - replayRecoveredEditsIfAny
```
protected long replayRecoveredEditsIfAny(org.apache.hadoop.fs.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:
    
    IOException
  - replayRecoveredEdits
```
private long replayRecoveredEdits(org.apache.hadoop.fs.Path edits,
                        Map<byte[],Long> maxSeqIdInStores,
                        CancelableProgressable reporter)
                           throws IOException
```
    Throws:
    
    IOException
  - replayWALCompactionMarker
```
void replayWALCompactionMarker(org.apache.hadoop.hbase.protobuf.generated.WALProtos.CompactionDescriptor compaction,
                             boolean pickCompactionFiles,
                             boolean removeFiles,
                             long replaySeqId)
                         throws IOException
```
    Call to complete a compaction. Its for the case where we find in the WAL a compaction that was not finished. We could find one recovering a WAL after a regionserver crash. See HBASE-2331.
    
    Throws:
    
    IOException
  - replayWALFlushMarker
```
void replayWALFlushMarker(org.apache.hadoop.hbase.protobuf.generated.WALProtos.FlushDescriptor flush,
                        long replaySeqId)
                    throws IOException
```
    Throws:
    
    IOException
  - replayWALFlushStartMarker
```
HRegion.PrepareFlushResult replayWALFlushStartMarker(org.apache.hadoop.hbase.protobuf.generated.WALProtos.FlushDescriptor flush)
                                               throws IOException
```
    Replay the flush marker from primary region by creating a corresponding snapshot of the store memstores, only if the memstores do not have a higher seqId from an earlier wal edit (because the events may be coming out of order).
    
    Throws:
    
    IOException
  - replayWALFlushCommitMarker
```
void replayWALFlushCommitMarker(org.apache.hadoop.hbase.protobuf.generated.WALProtos.FlushDescriptor flush)
                          throws IOException
```
    Throws:
    
    IOException
  - replayFlushInStores
```
private void replayFlushInStores(org.apache.hadoop.hbase.protobuf.generated.WALProtos.FlushDescriptor flush,
                       HRegion.PrepareFlushResult prepareFlushResult,
                       boolean dropMemstoreSnapshot)
                          throws IOException
```
    Replays the given flush descriptor by opening the flush files in stores and dropping the memstore snapshots if requested.
    
    Parameters:
    flush -
    prepareFlushResult -
    dropMemstoreSnapshot -
    
    Throws:
    
    IOException
  - dropMemstoreContentsForSeqId
```
private long dropMemstoreContentsForSeqId(long seqId,
                                Store store)
                                   throws IOException
```
    Drops the memstore contents after replaying a flush descriptor or region open event replay if the memstore edits have seqNums smaller than the given seq id
    
    Throws:
    
    IOException
  - doDropStoreMemstoreContentsForSeqId
```
private long doDropStoreMemstoreContentsForSeqId(Store s,
                                       long currentSeqId)
                                          throws IOException
```
    Throws:
    
    IOException
  - replayWALFlushAbortMarker
```
private void replayWALFlushAbortMarker(org.apache.hadoop.hbase.protobuf.generated.WALProtos.FlushDescriptor flush)
```
  - replayWALFlushCannotFlushMarker
```
private void replayWALFlushCannotFlushMarker(org.apache.hadoop.hbase.protobuf.generated.WALProtos.FlushDescriptor flush,
                                   long replaySeqId)
```
  - getPrepareFlushResult
```
HRegion.PrepareFlushResult getPrepareFlushResult()
```
  - replayWALRegionEventMarker
```
void replayWALRegionEventMarker(org.apache.hadoop.hbase.protobuf.generated.WALProtos.RegionEventDescriptor regionEvent)
                          throws IOException
```
    Throws:
    
    IOException
  - replayWALBulkLoadEventMarker
```
void replayWALBulkLoadEventMarker(org.apache.hadoop.hbase.protobuf.generated.WALProtos.BulkLoadDescriptor bulkLoadEvent)
                            throws IOException
```
    Throws:
    
    IOException
  - dropPrepareFlushIfPossible
```
private void dropPrepareFlushIfPossible()
```
    If all stores ended up dropping their snapshots, we can safely drop the prepareFlushResult
  - 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
  - logRegionFiles
```
private void logRegionFiles()
```
  - checkTargetRegion
```
private void checkTargetRegion(byte[] encodedRegionName,
                     String exceptionMsg,
                     Object payload)
                        throws WrongRegionException
```
    Checks whether the given regionName is either equal to our region, or that the regionName is the primary region to our corresponding range for the secondary replica.
    
    Throws:
    
    WrongRegionException
  - 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.
  - isZeroLengthThenDelete
```
private static boolean isZeroLengthThenDelete(org.apache.hadoop.fs.FileSystem fs,
                             org.apache.hadoop.fs.Path p)
                                       throws IOException
```
    Throws:
    
    IOException
  - 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
  - getStore
```
private Store getStore(Cell cell)
```
    Return HStore instance. Does not do any copy: as the number of store is limited, we iterate on the list.
  - 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
  - checkRow
```
void checkRow(byte[] row,
            String op)
        throws IOException
```
    Make sure this is a valid row for the HRegion
    
    Throws:
    
    IOException
  - 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 - if any error occurred
  - getRowLock
```
public Region.RowLock getRowLock(byte[] row,
                        boolean readLock)
                          throws IOException
```
    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).
    
    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-exlcusive lock is requested
    
    Returns:
    A locked RowLock.
    
    Throws:
    
    IOException - if any error occurred
  - getRowLock
```
public Region.RowLock getRowLock(byte[] row,
                        boolean readLock,
                        boolean waitForLock)
                          throws IOException
```
    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).
    
    Parameters:
    row - The row actions will be performed against
    readLock - is the lock reader or writer. True indicates that a non-exlcusive lock is requested
    waitForLock - whether should wait for this lock
    
    Returns:
    A locked RowLock, or null if waitForLock set to false and tryLock failed
    
    Throws:
    
    IOException - if any error occurred
  - 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
  - getLockedRows
```
public ConcurrentHashMap<HashedBytes,HRegion.RowLockContext> getLockedRows()
```
  - hasMultipleColumnFamilies
```
private static boolean hasMultipleColumnFamilies(Collection<Pair<byte[],String>> familyPaths)
```
    Determines whether multiple column families are present Precondition: familyPaths is not null
    
    Parameters:
    familyPaths - List of Pair
  - 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<byte[] column family, String hfilePath>
    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
  - newHRegion
```
static HRegion newHRegion(org.apache.hadoop.fs.Path tableDir,
                 WAL wal,
                 org.apache.hadoop.fs.FileSystem fs,
                 org.apache.hadoop.conf.Configuration conf,
                 HRegionInfo regionInfo,
                 HTableDescriptor 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 - - HRegionInfo 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(HRegionInfo info,
                    org.apache.hadoop.fs.Path rootDir,
                    org.apache.hadoop.conf.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,
                    org.apache.hadoop.fs.Path rootDir,
                    org.apache.hadoop.conf.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,
                    org.apache.hadoop.fs.Path rootDir,
                    org.apache.hadoop.conf.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,
                    org.apache.hadoop.fs.Path rootDir,
                    org.apache.hadoop.fs.Path tableDir,
                    org.apache.hadoop.conf.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,
                    org.apache.hadoop.fs.Path rootDir,
                    org.apache.hadoop.conf.Configuration conf,
                    HTableDescriptor hTableDescriptor,
                    WAL wal)
                             throws IOException
```
    Throws:
    
    IOException
  - openHRegion
```
public static HRegion openHRegion(HRegionInfo info,
                  HTableDescriptor 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(HRegionInfo info,
                  HTableDescriptor 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,
                  HRegionInfo info,
                  HTableDescriptor 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,
                  HRegionInfo info,
                  HTableDescriptor 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,
                  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(org.apache.hadoop.conf.Configuration conf,
                  org.apache.hadoop.fs.FileSystem fs,
                  org.apache.hadoop.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(org.apache.hadoop.conf.Configuration conf,
                  org.apache.hadoop.fs.FileSystem fs,
                  org.apache.hadoop.fs.Path rootDir,
                  org.apache.hadoop.fs.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,
                 org.apache.hadoop.conf.Configuration conf,
                 RegionServerServices rsServices,
                 CancelableProgressable reporter)
                          throws IOException
```
    Throws:
    
    IOException
  - checkCompressionCodecs
```
private void checkCompressionCodecs()
                             throws IOException
```
    Throws:
    
    IOException
  - checkEncryption
```
private void checkEncryption()
                      throws IOException
```
    Throws:
    
    IOException
  - checkClassLoading
```
private void checkClassLoading()
                        throws IOException
```
    Throws:
    
    IOException
  - createDaughterRegionFromSplits
```
HRegion createDaughterRegionFromSplits(HRegionInfo hri)
                                 throws IOException
```
    Create a daughter region from given a temp directory with the region data.
    
    Parameters:
    hri - Spec. for daughter region to open.
    
    Throws:
    
    IOException
  - createMergedRegionFromMerges
```
HRegion createMergedRegionFromMerges(HRegionInfo mergedRegionInfo,
                                   HRegion region_b)
                               throws IOException
```
    Create a merged region given a temp directory with the region data.
    
    Parameters:
    region_b - another merging region
    
    Returns:
    merged HRegion
    
    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 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
  - getRegionDir
```
@Deprecated
public static org.apache.hadoop.fs.Path getRegionDir(org.apache.hadoop.fs.Path rootdir,
                                                HRegionInfo info)
```
    Deprecated. For tests only; to be removed.
    
    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
  - buildScanForGetWithClosestRowBefore
```
private Scan buildScanForGetWithClosestRowBefore(Get get)
                                          throws IOException
```
    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 org.apache.hadoop.hbase.protobuf.generated.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
  - doProcessRowWithTimeout
```
private void doProcessRowWithTimeout(RowProcessor<?,?> processor,
                           long now,
                           HRegion region,
                           List<Mutation> mutations,
                           WALEdit walEdit,
                           long timeout)
                              throws IOException
```
    Throws:
    
    IOException
  - carryForwardTags
```
private static List<Tag> carryForwardTags(Cell cell,
                         List<Tag> tags)
```
    Parameters:
    cell -
    tags -
    
    Returns:
    The passed-in List but with the tags from cell added.
  - doGet
```
private List<Cell> doGet(Store store,
               byte[] row,
               Map.Entry<byte[],List<Cell>> family,
               TimeRange tr)
                  throws IOException
```
    Run a Get against passed in store on passed row, etc.
    
    Parameters:
    store -
    row -
    family -
    tr -
    
    Returns:
    Get result.
    
    Throws:
    
    IOException
  - append
```
public Result append(Append append)
              throws IOException
```
    Throws:
    
    IOException
  - dropMemstoreContents
```
private void dropMemstoreContents()
                           throws IOException
```
    Throws:
    
    IOException
  - append
```
public Result append(Append mutate,
            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
  - getNewCell
```
private static Cell getNewCell(byte[] row,
              long ts,
              Cell cell,
              Cell oldCell,
              byte[] tagBytes)
```
  - getNewCell
```
private static Cell getNewCell(Mutation mutate,
              Cell cell)
```
  - increment
```
public Result increment(Increment increment)
                 throws IOException
```
    Throws:
    
    IOException
  - increment
```
public Result increment(Increment mutation,
               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
  - doIncrement
```
private Result doIncrement(Increment increment,
                 long nonceGroup,
                 long nonce)
                    throws IOException
```
    Throws:
    
    IOException
  - sort
```
private static List<Cell> sort(List<Cell> cells,
              Comparator<Cell> comparator)
```
    Returns:
    Sorted list of cells using comparator
  - applyIncrementsToColumnFamily
```
private List<Cell> applyIncrementsToColumnFamily(Increment increment,
                                       byte[] columnFamilyName,
                                       List<Cell> sortedIncrements,
                                       long now,
                                       long mvccNum,
                                       List<Cell> allKVs,
                                       IsolationLevel isolation)
                                          throws IOException
```
    Apply increments to a column family.
    
    Parameters:
    sortedIncrements - The passed in increments to apply MUST be sorted so that they match the order that they appear in the Get results (get results will be sorted on return). Otherwise, we won't be able to find the existing values if the cells are not specified in order by the client since cells are in an array list.
    
    Returns:
    Resulting increments after sortedIncrements have been applied to current values (if any -- else passed increment is the final result).
    
    Throws:
    
    IOException
  - getLongValue
```
private static long getLongValue(Cell cell)
                          throws DoNotRetryIOException
```
    Returns:
    Get the long out of the passed in Cell
    
    Throws:
    
    DoNotRetryIOException
  - getIncrementCurrentValue
```
private List<Cell> getIncrementCurrentValue(Increment increment,
                                  byte[] columnFamily,
                                  List<Cell> increments,
                                  IsolationLevel isolation)
                                     throws IOException
```
    Do a specific Get on passed columnFamily and column qualifiers from incrementCoordinates only.
    
    Parameters:
    increment -
    columnFamily -
    incrementCoordinates -
    
    Returns:
    Return the Cells to Increment
    
    Throws:
    
    IOException
  - carryForwardTTLTag
```
private static List<Tag> carryForwardTTLTag(Mutation mutation)
```
  - carryForwardTTLTag
```
private static List<Tag> carryForwardTTLTag(List<Tag> tagsOrNull,
                           Mutation mutation)
```
    Returns:
    Carry forward the TTL tag if the increment is carrying one
  - checkFamily
```
private void checkFamily(byte[] family)
                  throws NoSuchColumnFamilyException
```
    Throws:
    
    NoSuchColumnFamilyException
  - 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.
  - printUsageAndExit
```
private static void printUsageAndExit(String message)
```
  - registerService
```
public boolean registerService(com.google.protobuf.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 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 com.google.protobuf.Message execService(com.google.protobuf.RpcController controller,
                                      org.apache.hadoop.hbase.protobuf.generated.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:
    Region.registerService(com.google.protobuf.Service)
  - processTable
```
private static void processTable(org.apache.hadoop.fs.FileSystem fs,
                org.apache.hadoop.fs.Path p,
                WALFactory walFactory,
                org.apache.hadoop.conf.Configuration c,
                boolean majorCompact)
                          throws IOException
```
    Throws:
    
    IOException
  - shouldForceSplit
```
boolean shouldForceSplit()
```
  - getExplicitSplitPoint
```
byte[] getExplicitSplitPoint()
```
  - forceSplit
```
void forceSplit(byte[] sp)
```
  - clearSplit
```
void clearSplit()
```
  - 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
  - startBulkRegionOperation
```
private void startBulkRegionOperation(boolean writeLockNeeded)
                               throws NotServingRegionException,
                                      RegionTooBusyException,
                                      InterruptedIOException
```
    This method needs to be called before any public call that reads or modifies stores in bulk. It has to be called just before a try. #closeBulkRegionOperation needs to be called in the try's finally block Acquires a writelock and checks if the region is closing or closed.
    
    Throws:
    
    NotServingRegionException - when the region is closing or closed
    
    RegionTooBusyException - if failed to get the lock in time
    
    InterruptedIOException - if interrupted while waiting for a lock
  - closeBulkRegionOperation
```
private void closeBulkRegionOperation()
```
    Closes the lock. This needs to be called in the finally block corresponding to the try block of #startRegionOperation
  - recordMutationWithoutWal
```
private void recordMutationWithoutWal(Map<byte[],List<Cell>> familyMap)
```
    Update counters for number of puts without wal and the size of possible data loss. These information are exposed by the region server metrics.
  - lock
```
private void lock(Lock lock)
           throws RegionTooBusyException,
                  InterruptedIOException
```
    Throws:
    
    RegionTooBusyException
    
    InterruptedIOException
  - lock
```
private void lock(Lock lock,
        int multiplier)
           throws RegionTooBusyException,
                  InterruptedIOException
```
    Try to acquire a lock. Throw RegionTooBusyException if failed to get the lock in time. Throw InterruptedIOException if interrupted while waiting for the lock.
    
    Throws:
    
    RegionTooBusyException
    
    InterruptedIOException
  - syncOrDefer
```
private void syncOrDefer(long txid,
               Durability durability)
                  throws IOException
```
    Calls sync with the given transaction ID if the region's table is not deferring it.
    
    Parameters:
    txid - should sync up to which transaction
    
    Throws:
    
    IOException - If anything goes wrong with DFS
  - shouldSyncWAL
```
private boolean shouldSyncWAL()
```
    Check whether we should sync the wal from the table's durability settings
  - 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 flushed sequence id for the given family; can be beyond Region.getMaxFlushedSeqId() in case where we've flushed a subset of a regions column families
  - getCompactionState
```
public org.apache.hadoop.hbase.protobuf.generated.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 long getSequenceId()
```
    Do not change this sequence id.
    
    Returns:
    sequenceId
  - appendEmptyEdit
```
private WALKey appendEmptyEdit(WAL wal)
                        throws IOException
```
    Append a faked WALEdit in order to get a long sequence number and wal syncer will just ignore the WALEdit append later.
    
    Parameters:
    wal -
    
    Returns:
    Return the key used appending with no sync and no append.
    
    Throws:
    
    IOException
  - onConfigurationChange
```
public void onConfigurationChange(org.apache.hadoop.conf.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

maxWaitForSeqId

MAX_WAIT_FOR_SEQ_ID_KEY

DEFAULT_MAX_WAIT_FOR_SEQ_ID

DEFAULT_DURABILITY

closed

closing

maxFlushedSeqId

lastFlushOpSeqId

lastReplayedOpenRegionSeqId

lastReplayedCompactionSeqId

storeSeqIds

lockedRows

stores

coprocessorServiceHandlers

memstoreSize

numMutationsWithoutWAL

dataInMemoryWithoutWAL

checkAndMutateChecksPassed

checkAndMutateChecksFailed

readRequestsCount

writeRequestsCount

blockedRequestsCount

compactionsFinished

compactionNumFilesCompacted

compactionNumBytesCompacted

wal

fs

conf

baseConf

comparator

rowLockWaitDuration

DEFAULT_ROWLOCK_WAIT_DURATION

busyWaitDuration

DEFAULT_BUSY_WAIT_DURATION

maxBusyWaitMultiplier

maxBusyWaitDuration

DEFAULT_ROW_PROCESSOR_TIMEOUT

rowProcessorExecutor

scannerReadPoints

openSeqNum

isLoadingCfsOnDemandDefault

majorInProgress

minorInProgress

maxSeqIdInStores

prepareFlushResult

disallowWritesInRecovering

recovering

configurationManager

writestate

memstoreFlushSize

timestampSlop

rowProcessorTimeout

lastStoreFlushTimeMap

rsServices

rsAccounting

flushCheckInterval

flushPerChanges

blockingMemStoreSize

threadWakeFrequency

lock

updatesLock

splitRequest

explicitSplitPoint

mvcc

coprocessorHost

htableDescriptor

splitPolicy

flushPolicy

metricsRegion

metricsRegionWrapper