HRegion (Apache HBase 2.2.3 API)

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

All Implemented Interfaces:

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

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`private static class`	`HRegion.BatchOperation<T>` Class that tracks the progress of a batch operations, accumulating status codes and tracking the index at which processing is proceeding.
`static interface`	`HRegion.BulkLoadListener` Listener class to enable callers of bulkLoadHFile() to perform any necessary pre/post processing of a given bulkload call
`static interface`	`HRegion.FlushResult`
`static class`	`HRegion.FlushResultImpl` Objects from this class are created when flushing to describe all the different states that that method ends up in.
`(package private) static class`	`HRegion.MutationBatchOperation` Batch of mutation operations.
`(package private) static class`	`HRegion.ObservedExceptionsInBatch` A class that tracks exceptions that have been observed in one batch.
`(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).
`(package private) static class`	`HRegion.ReplayBatchOperation` Batch of mutations for replay.
`(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.Operation, Region.RowLock

Field Summary

Fields
Modifier and Type	Field and Description
`private org.apache.hadoop.conf.Configuration`	`baseConf`
`private BlockCache`	`blockCache`
`private LongAdder`	`blockedRequestsCount`
`private long`	`blockingMemStoreSize`
`(package private) long`	`busyWaitDuration`
`(package private) LongAdder`	`checkAndMutateChecksFailed`
`(package private) LongAdder`	`checkAndMutateChecksPassed`
`(package private) AtomicBoolean`	`closed`
`private Object`	`closeLock`
`(package private) AtomicBoolean`	`closing`
`(package private) LongAdder`	`compactionNumBytesCompacted`
`(package private) LongAdder`	`compactionNumFilesCompacted`
`(package private) LongAdder`	`compactionsFailed`
`(package private) LongAdder`	`compactionsFinished`
`(package private) LongAdder`	`compactionsQueued`
`protected org.apache.hadoop.conf.Configuration`	`conf`
`private ConfigurationManager`	`configurationManager`
`private RegionCoprocessorHost`	`coprocessorHost`
`private Map<String,com.google.protobuf.Service>`	`coprocessorServiceHandlers`
`(package private) LongAdder`	`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`
`static int`	`DEFAULT_HBASE_REGIONSERVER_MINIBATCH_SIZE`
`static int`	`DEFAULT_MAX_CELL_SIZE`
`(package private) static long`	`DEFAULT_ROW_PROCESSOR_TIMEOUT`
`(package private) static int`	`DEFAULT_ROWLOCK_WAIT_DURATION`
`static boolean`	`DEFAULT_WAL_HSYNC`
`private byte[]`	`explicitSplitPoint`
`(package private) LongAdder`	`filteredReadRequestsCount`
`static long`	`FIXED_OVERHEAD`
`private long`	`flushCheckInterval`
`(package private) LongAdder`	`flushesQueued`
`private long`	`flushPerChanges`
`private FlushPolicy`	`flushPolicy`
`private static byte[]`	`FOR_UNIT_TESTS_ONLY` Row needed by below method.
`private HRegionFileSystem`	`fs`
`static String`	`HBASE_MAX_CELL_SIZE_KEY`
`static String`	`HBASE_REGIONSERVER_MINIBATCH_SIZE`
`private TableDescriptor`	`htableDescriptor`
`private boolean`	`isLoadingCfsOnDemandDefault` The default setting for whether to enable on-demand CF loading for scan requests to this region.
`private boolean`	`isRestoredRegion`
`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<HStore,Long>`	`lastStoreFlushTimeMap`
`static String`	`LOAD_CFS_ON_DEMAND_CONFIG_KEY`
`(package private) ReentrantReadWriteLock`	`lock`
`private ConcurrentHashMap<HashedBytes,HRegion.RowLockContext>`	`lockedRows`
`private static org.slf4j.Logger`	`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.
`(package private) long`	`maxBusyWaitDuration`
`(package private) int`	`maxBusyWaitMultiplier`
`(package private) long`	`maxCellSize`
`private long`	`maxFlushedSeqId` The max sequence id of flushed data on this region.
`(package private) Map<byte[],Long>`	`maxSeqIdInStores`
`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 MemStoreSizing`	`memStoreSizing`
`private MetricsRegion`	`metricsRegion`
`private MetricsRegionWrapperImpl`	`metricsRegionWrapper`
`private int`	`miniBatchSize`
`private AtomicInteger`	`minorInProgress`
`private MobFileCache`	`mobFileCache`
`private static List<Cell>`	`MOCKED_LIST` A mocked list implementation - discards all updates.
`private MultiVersionConcurrencyControl`	`mvcc`
`(package private) LongAdder`	`numMutationsWithoutWAL`
`private long`	`openSeqNum` The sequence ID that was enLongAddered when this region was opened.
`private HRegion.PrepareFlushResult`	`prepareFlushResult` Saved state from replaying prepare flush cache
`(package private) LongAdder`	`readRequestsCount`
`private org.apache.hadoop.fs.Path`	`regionDir`
`private Durability`	`regionDurability`
`(package private) RegionServicesForStores`	`regionServicesForStores`
`private boolean`	`regionStatsEnabled`
`private NavigableMap<byte[],Integer>`	`replicationScope`
`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`
`private StoreHotnessProtector`	`storeHotnessProtector`
`protected Map<byte[],HStore>`	`stores`
`static int`	`SYSTEM_CACHE_FLUSH_INTERVAL` Default interval for System tables memstore flush
`private Long`	`timeoutForWriteLock`
`(package private) long`	`timestampSlop`
`private ReentrantReadWriteLock`	`updatesLock`
`private WAL`	`wal`
`static String`	`WAL_HSYNC_CONF_KEY`
`private org.apache.hadoop.fs.FileSystem`	`walFS`
`(package private) LongAdder`	`writeRequestsCount`
`(package private) HRegion.WriteState`	`writestate`

Constructor Summary

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

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`addRegionToSnapshot(org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription desc, ForeignExceptionSnare exnSnare)` Complete taking the snapshot on the region.
`Result`	`append(Append append)` Perform one or more append operations on a row.
`Result`	`append(Append mutation, long nonceGroup, long nonce)`
`private void`	`applyToMemStore(HStore store, Cell cell, MemStoreSizing memstoreAccounting)`
`private void`	`applyToMemStore(HStore store, List<Cell> cells, boolean delta, MemStoreSizing memstoreAccounting)`
`boolean`	`areWritesEnabled()`
`(package private) OperationStatus[]`	`batchMutate(HRegion.BatchOperation<?> batchOp)` Perform a batch of mutations.
`OperationStatus[]`	`batchMutate(Mutation[] mutations)` Perform a batch of mutations.
`OperationStatus[]`	`batchMutate(Mutation[] mutations, boolean atomic, long nonceGroup, long nonce)`
`OperationStatus[]`	`batchMutate(Mutation[] mutations, long nonceGroup, long nonce)`
`OperationStatus[]`	`batchReplay(WALSplitUtil.MutationReplay[] mutations, long replaySeqId)`
`void`	`blockUpdates()`
`Map<byte[],List<org.apache.hadoop.fs.Path>>`	`bulkLoadHFiles(Collection<Pair<byte[],String>> familyPaths, boolean assignSeqId, HRegion.BulkLoadListener bulkLoadListener)` Attempts to atomically load a group of hfiles.
`Map<byte[],List<org.apache.hadoop.fs.Path>>`	`bulkLoadHFiles(Collection<Pair<byte[],String>> familyPaths, boolean assignSeqId, HRegion.BulkLoadListener bulkLoadListener, boolean copyFile, List<String> clusterIds, boolean replicate)` Attempts to atomically load a group of hfiles.
`boolean`	`checkAndMutate(byte[] row, byte[] family, byte[] qualifier, CompareOperator op, ByteArrayComparable comparator, TimeRange timeRange, Mutation mutation)` Atomically checks if a row/family/qualifier value matches the expected value and if it does, it performs the mutation.
`boolean`	`checkAndRowMutate(byte[] row, byte[] family, byte[] qualifier, CompareOperator op, ByteArrayComparable comparator, TimeRange timeRange, RowMutations rm)` Atomically checks if a row/family/qualifier value matches the expected values and if it does, it performs the row mutations.
`void`	`checkFamilies(Collection<byte[]> families)` Check the collection of families for validity.
`(package private) void`	`checkFamily(byte[] family)`
`private void`	`checkMutationType(Mutation mutation, byte[] row)`
`private void`	`checkNegativeMemStoreDataSize(long memStoreDataSize, long delta)`
`protected void`	`checkReadOnly()`
`protected void`	`checkReadsEnabled()`
`(package 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<HStoreFile>>`	`close()` Close down this HRegion.
`Map<byte[],List<HStoreFile>>`	`close(boolean abort)` Close down this HRegion.
`private void`	`closeBulkRegionOperation()` Closes the lock.
`void`	`closeRegionOperation()` Closes the region operation lock.
`void`	`closeRegionOperation(Region.Operation operation)` Closes the region operation lock.
`void`	`compact(boolean majorCompaction)` Synchronously compact all stores in the region.
`boolean`	`compact(CompactionContext compaction, HStore store, ThroughputController throughputController)` Called by compaction thread and after region is opened to compact the HStores if necessary.
`boolean`	`compact(CompactionContext compaction, HStore store, ThroughputController throughputController, User user)`
`(package private) void`	`compactStore(byte[] family, ThroughputController throughputController)` This is a helper function that compact the given store.
`void`	`compactStores()` This is a helper function that compact all the stores synchronously.
`static HDFSBlocksDistribution`	`computeHDFSBlocksDistribution(org.apache.hadoop.conf.Configuration conf, TableDescriptor tableDescriptor, RegionInfo regionInfo)` This is a helper function to compute HDFS block distribution on demand
`static HDFSBlocksDistribution`	`computeHDFSBlocksDistribution(org.apache.hadoop.conf.Configuration conf, TableDescriptor tableDescriptor, RegionInfo regionInfo, org.apache.hadoop.fs.Path tablePath)` This is a helper function to compute HDFS block distribution on demand
`static HRegion`	`createHRegion(RegionInfo info, org.apache.hadoop.fs.Path rootDir, org.apache.hadoop.conf.Configuration conf, TableDescriptor hTableDescriptor, WAL wal)`
`static HRegion`	`createHRegion(RegionInfo info, org.apache.hadoop.fs.Path rootDir, org.apache.hadoop.conf.Configuration conf, TableDescriptor hTableDescriptor, WAL wal, boolean initialize)` Convenience method creating new HRegions.
`static HRegionFileSystem`	`createRegionDir(org.apache.hadoop.conf.Configuration configuration, RegionInfo ri, org.apache.hadoop.fs.Path rootDir)` Create the region directory in the filesystem.
`(package private) static void`	`decorateRegionConfiguration(org.apache.hadoop.conf.Configuration conf)` This method modifies the region's configuration in order to inject replication-related features
`void`	`decrementCompactionsQueuedCount()`
`(package private) void`	`decrMemStoreSize(long dataSizeDelta, long heapSizeDelta, long offHeapSizeDelta, int cellsCountDelta)`
`(package private) void`	`decrMemStoreSize(MemStoreSize mss)`
`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`	`doAbortFlushToWAL(WAL wal, long flushOpSeqId, Map<byte[],List<org.apache.hadoop.fs.Path>> committedFiles)`
`private void`	`doBatchMutate(Mutation mutation)`
`private boolean`	`doCheckAndRowMutate(byte[] row, byte[] family, byte[] qualifier, CompareOperator op, ByteArrayComparable comparator, TimeRange timeRange, RowMutations rowMutations, Mutation mutation)` checkAndMutate and checkAndRowMutate are 90% the same.
`private Map<byte[],List<HStoreFile>>`	`doClose(boolean abort, MonitoredTask status)`
`private Result`	`doCoprocessorPreCall(Region.Operation op, Mutation mutation)` Do coprocessor pre-increment or pre-append call.
`private Result`	`doDelta(Region.Operation op, Mutation mutation, long nonceGroup, long nonce, boolean returnResults)` Add "deltas" to Cells.
`private MemStoreSize`	`doDropStoreMemStoreContentsForSeqId(HStore s, long currentSeqId)`
`private void`	`doMiniBatchMutate(HRegion.BatchOperation<?> batchOp)` Called to do a piece of the batch that came in to `batchMutate(Mutation[], long, long)` In here we also handle replay of edits on region recover.
`private void`	`doProcessRowWithTimeout(RowProcessor<?,?> processor, long now, HRegion region, List<Mutation> mutations, WALEdit walEdit, long timeout)`
`protected void`	`doRegionCompactionPrep()` Do preparation for pending compaction.
`private static void`	`doSyncOfUnflushedWALChanges(WAL wal, RegionInfo hri)` Sync unflushed WAL changes.
`private MultiVersionConcurrencyControl.WriteEntry`	`doWALAppend(WALEdit walEdit, Durability durability, List<UUID> clusterIds, long now, long nonceGroup, long nonce)`
`private MultiVersionConcurrencyControl.WriteEntry`	`doWALAppend(WALEdit walEdit, Durability durability, List<UUID> clusterIds, long now, long nonceGroup, long nonce, long origLogSeqNum)`
`private MultiVersionConcurrencyControl.WriteEntry`	`doWALAppend(WALEdit walEdit, Durability durability, long nonceGroup, long nonce)`
`MemStoreSize`	`dropMemStoreContents()` Be careful, this method will drop all data in the memstore of this region.
`private MemStoreSize`	`dropMemStoreContentsForSeqId(long seqId, HStore 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.shaded.protobuf.generated.ClientProtos.CoprocessorServiceCall call)` Executes a single protocol buffer coprocessor endpoint `Service` method using the registered protocol handlers.
`HRegion.FlushResult`	`flush(boolean force)` Flush the cache.
`HRegion.FlushResultImpl`	`flushcache(boolean forceFlushAllStores, boolean writeFlushRequestWalMarker, FlushLifeCycleTracker tracker)` 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.
`List<Cell>`	`get(Get get, boolean withCoprocessor, long nonceGroup, long nonce)`
`private List<Cell>`	`get(Mutation mutation, HStore store, List<Cell> coordinates, IsolationLevel isolation, TimeRange tr)` Do a specific Get on passed `columnFamily` and column qualifiers.
`(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.
`BlockCache`	`getBlockCache()`
`long`	`getBlockedRequestsCount()`
`CellComparator`	`getCellComparator()` The comparator to be used with the region
`long`	`getCheckAndMutateChecksFailed()`
`long`	`getCheckAndMutateChecksPassed()`
`CompactionState`	`getCompactionState()`
`int`	`getCompactPriority()`
`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()`
`long`	`getFilteredReadRequestsCount()`
`HDFSBlocksDistribution`	`getHDFSBlocksDistribution()`
`org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.RegionLoadStats`	`getLoadStatistics()`
`ConcurrentHashMap<HashedBytes,HRegion.RowLockContext>`	`getLockedRows()`
`private static long`	`getLongValue(Cell cell)`
`long`	`getMaxFlushedSeqId()`
`Map<byte[],Long>`	`getMaxStoreSeqId()`
`long`	`getMemStoreDataSize()`
`long`	`getMemStoreFlushSize()`
`long`	`getMemStoreHeapSize()`
`long`	`getMemStoreOffHeapSize()`
`MetricsRegion`	`getMetrics()`
`MobFileCache`	`getMobFileCache()`
`MultiVersionConcurrencyControl`	`getMVCC()`
`protected long`	`getNextSequenceId(WAL wal)` Method to safely get the next sequence number.
`long`	`getNumMutationsWithoutWAL()`
`long`	`getOldestHfileTs(boolean majorCompactionOnly)` This can be used to determine the last time all files of this region were major compacted.
`long`	`getOldestSeqIdOfStore(byte[] familyName)`
`(package private) static ThreadPoolExecutor`	`getOpenAndCloseThreadPool(int maxThreads, String threadNamePrefix)`
`long`	`getOpenSeqNum()`
`(package private) HRegion.PrepareFlushResult`	`getPrepareFlushResult()`
`int`	`getReadLockCount()`
`long`	`getReadPoint()`
`long`	`getReadPoint(IsolationLevel isolationLevel)`
`long`	`getReadRequestsCount()`
`static org.apache.hadoop.fs.Path`	`getRegionDir(org.apache.hadoop.fs.Path tabledir, String name)` Deprecated. For tests only; to be removed.
`HRegionFileSystem`	`getRegionFileSystem()`
`RegionInfo`	`getRegionInfo()`
`(package private) RegionServerServices`	`getRegionServerServices()`
`RegionServicesForStores`	`getRegionServicesForStores()`
`(package private) HRegionWALFileSystem`	`getRegionWALFileSystem()`
`NavigableMap<byte[],Integer>`	`getReplicationScope()`
`Region.RowLock`	`getRowLock(byte[] row)` Get an exclusive ( write lock ) lock on a given row.
`Region.RowLock`	`getRowLock(byte[] row, boolean readLock)` Get a row lock for the specified row.
`protected Region.RowLock`	`getRowLockInternal(byte[] row, boolean readLock, Region.RowLock prevRowLock)`
`HRegion.RegionScannerImpl`	`getScanner(Scan scan)` Return an iterator that scans over the HRegion, returning the indicated columns and rows specified by the `Scan`.
`HRegion.RegionScannerImpl`	`getScanner(Scan scan, List<KeyValueScanner> additionalScanners)` Return an iterator that scans over the HRegion, returning the indicated columns and rows specified by the `Scan`.
`private HRegion.RegionScannerImpl`	`getScanner(Scan scan, List<KeyValueScanner> additionalScanners, long nonceGroup, long nonce)`
`long`	`getSmallestReadPoint()`
`RegionSplitPolicy`	`getSplitPolicy()`
`HStore`	`getStore(byte[] column)` Return the Store for the given family
`private HStore`	`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<HStore>`	`getStores()` Return the list of Stores managed by this region
`TableDescriptor`	`getTableDescriptor()`
`WAL`	`getWAL()`
`(package private) org.apache.hadoop.fs.FileSystem`	`getWalFileSystem()`
`org.apache.hadoop.fs.Path`	`getWALRegionDir()`
`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()`
`(package private) void`	`incMemStoreSize(long dataSizeDelta, long heapSizeDelta, long offHeapSizeDelta, int cellsCountDelta)`
`(package private) void`	`incMemStoreSize(MemStoreSize mss)` Increase the size of mem store in this region and the size of global mem store
`Result`	`increment(Increment increment)` Perform one or more increment operations on a row.
`Result`	`increment(Increment mutation, long nonceGroup, long nonce)`
`void`	`incrementCompactionsQueuedCount()`
`void`	`incrementFlushesQueuedCount()`
`long`	`initialize()` Deprecated. use HRegion.createHRegion() or HRegion.openHRegion()
`(package 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 long`	`initializeStores(CancelableProgressable reporter, MonitoredTask status, boolean warmup)`
`private void`	`initializeWarmup(CancelableProgressable reporter)`
`protected HStore`	`instantiateHStore(ColumnFamilyDescriptor family, boolean warmup)`
`protected RegionScanner`	`instantiateRegionScanner(Scan scan, List<KeyValueScanner> additionalScanners)`
`protected HRegion.RegionScannerImpl`	`instantiateRegionScanner(Scan scan, List<KeyValueScanner> additionalScanners, long nonceGroup, long nonce)`
`private HRegion.FlushResultImpl`	`internalFlushcache(Collection<HStore> storesToFlush, MonitoredTask status, boolean writeFlushWalMarker, FlushLifeCycleTracker tracker)` Flushing given stores.
`private HRegion.FlushResult`	`internalFlushcache(MonitoredTask status)` Flushing all stores.
`protected HRegion.FlushResultImpl`	`internalFlushcache(WAL wal, long myseqid, Collection<HStore> storesToFlush, MonitoredTask status, boolean writeFlushWalMarker, FlushLifeCycleTracker tracker)` Flush the memstore.
`protected HRegion.FlushResultImpl`	`internalFlushCacheAndCommit(WAL wal, MonitoredTask status, HRegion.PrepareFlushResult prepareResult, Collection<HStore> storesToFlush)`
`protected HRegion.PrepareFlushResult`	`internalPrepareFlushCache(WAL wal, long myseqid, Collection<HStore> storesToFlush, MonitoredTask status, boolean writeFlushWalMarker, FlushLifeCycleTracker tracker)`
`private boolean`	`isAllFamilies(Collection<HStore> families)`
`boolean`	`isAvailable()`
`boolean`	`isClosed()`
`boolean`	`isClosing()`
`private boolean`	`isFlushSize(MemStoreSize size)`
`boolean`	`isLoadingCfsOnDemandDefault()`
`boolean`	`isMergeable()`
`boolean`	`isReadOnly()`
`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`	`logFatLineOnFlush(Collection<HStore> storesToFlush, long sequenceId)` Utility method broken out of internalPrepareFlushCache so that method is smaller.
`private void`	`logRegionFiles()`
`private boolean`	`matches(CompareOperator op, int compareResult)`
`(package private) void`	`metricsUpdateForGet(List<Cell> results, long before)`
`void`	`mutateRow(RowMutations rm)` Performs multiple mutations atomically on a single row.
`void`	`mutateRowsWithLocks(Collection<Mutation> mutations, Collection<byte[]> rowsToLock, long nonceGroup, long nonce)` Perform atomic (all or none) mutations within the region.
`static HRegion`	`newHRegion(org.apache.hadoop.fs.Path tableDir, WAL wal, org.apache.hadoop.fs.FileSystem fs, org.apache.hadoop.conf.Configuration conf, RegionInfo regionInfo, TableDescriptor htd, RegionServerServices rsServices)` A utility method to create new instances of HRegion based on the `HConstants.REGION_IMPL` configuration property.
`void`	`onConfigurationChange(org.apache.hadoop.conf.Configuration conf)` 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, org.apache.hadoop.fs.Path tableDir, RegionInfo info, TableDescriptor 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, RegionInfo info, TableDescriptor htd, WAL wal)` Open a Region.
`static HRegion`	`openHRegion(org.apache.hadoop.conf.Configuration conf, org.apache.hadoop.fs.FileSystem fs, org.apache.hadoop.fs.Path rootDir, RegionInfo info, TableDescriptor htd, WAL wal, RegionServerServices rsServices, CancelableProgressable reporter)` Open a Region.
`static HRegion`	`openHRegion(HRegion other, CancelableProgressable reporter)` Useful when reopening a closed region (normally for unit tests)
`static HRegion`	`openHRegion(org.apache.hadoop.fs.Path rootDir, RegionInfo info, TableDescriptor htd, WAL wal, org.apache.hadoop.conf.Configuration conf)` Open a Region.
`static HRegion`	`openHRegion(org.apache.hadoop.fs.Path rootDir, RegionInfo info, TableDescriptor htd, WAL wal, org.apache.hadoop.conf.Configuration conf, RegionServerServices rsServices, CancelableProgressable reporter)` Open a Region.
`static Region`	`openHRegion(Region other, CancelableProgressable reporter)`
`static HRegion`	`openHRegion(RegionInfo info, TableDescriptor htd, WAL wal, org.apache.hadoop.conf.Configuration conf)` Open a Region.
`static HRegion`	`openHRegion(RegionInfo info, TableDescriptor htd, WAL wal, org.apache.hadoop.conf.Configuration conf, RegionServerServices rsServices, CancelableProgressable reporter)` Open a Region.
`static HRegion`	`openReadOnlyFileSystemHRegion(org.apache.hadoop.conf.Configuration conf, org.apache.hadoop.fs.FileSystem fs, org.apache.hadoop.fs.Path tableDir, RegionInfo info, TableDescriptor htd)` Open a Region on a read-only file-system (like hdfs snapshots)
`void`	`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.
`(package private) void`	`prepareGet(Get get)`
`private void`	`preProcess(RowProcessor<?,?> processor, WALEdit walEdit)`
`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.
`(package 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 static Cell`	`reckonDelta(Cell delta, Cell currentCell, byte[] columnFamily, long now, Mutation mutation, Function<Cell,byte[]> supplier)`
`private WALEdit`	`reckonDeltas(Region.Operation op, Mutation mutation, Durability effectiveDurability, Map<HStore,List<Cell>> forMemStore, List<Cell> results)` Reckon the Cells to apply to WAL, memstore, and to return to the Client; these Sets are not always the same dependent on whether to write WAL.
`private List<Cell>`	`reckonDeltasByStore(HStore store, Region.Operation op, Mutation mutation, Durability effectiveDurability, long now, List<Cell> deltas, List<Cell> results)` Reckon the Cells to apply to WAL, memstore, and to return to the Client in passed column family/Store.
`private void`	`recordMutationWithoutWal(Map<byte[],List<Cell>> familyMap)` Update LongAdders 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.
`private void`	`releaseRowLocks(List<Region.RowLock> rowLocks)`
`private void`	`replayFlushInStores(org.apache.hadoop.hbase.shaded.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, org.apache.hadoop.fs.FileSystem fs)`
`private long`	`replayRecoveredEditsForPaths(long minSeqIdForTheRegion, org.apache.hadoop.fs.FileSystem fs, NavigableSet<org.apache.hadoop.fs.Path> files, CancelableProgressable reporter, org.apache.hadoop.fs.Path regionDir)`
`protected long`	`replayRecoveredEditsIfAny(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.shaded.protobuf.generated.WALProtos.BulkLoadDescriptor bulkLoadEvent)`
`(package private) void`	`replayWALCompactionMarker(org.apache.hadoop.hbase.shaded.protobuf.generated.WALProtos.CompactionDescriptor compaction, boolean pickCompactionFiles, boolean removeFiles, long replaySeqId)` Call to complete a compaction.
`private void`	`replayWALFlushAbortMarker(org.apache.hadoop.hbase.shaded.protobuf.generated.WALProtos.FlushDescriptor flush)`
`private void`	`replayWALFlushCannotFlushMarker(org.apache.hadoop.hbase.shaded.protobuf.generated.WALProtos.FlushDescriptor flush, long replaySeqId)`
`(package private) void`	`replayWALFlushCommitMarker(org.apache.hadoop.hbase.shaded.protobuf.generated.WALProtos.FlushDescriptor flush)`
`(package private) void`	`replayWALFlushMarker(org.apache.hadoop.hbase.shaded.protobuf.generated.WALProtos.FlushDescriptor flush, long replaySeqId)`
`(package private) HRegion.PrepareFlushResult`	`replayWALFlushStartMarker(org.apache.hadoop.hbase.shaded.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.shaded.protobuf.generated.WALProtos.RegionEventDescriptor regionEvent)`
`void`	`reportCompactionRequestEnd(boolean isMajor, int numFiles, long filesSizeCompacted)`
`void`	`reportCompactionRequestFailure()`
`void`	`reportCompactionRequestStart(boolean isMajor)`
`void`	`requestCompaction(byte[] family, String why, int priority, boolean major, CompactionLifeCycleTracker tracker)` Request compaction for the given family
`void`	`requestCompaction(String why, int priority, boolean major, CompactionLifeCycleTracker tracker)` Request compaction on this region.
`private void`	`requestFlush()`
`void`	`requestFlush(FlushLifeCycleTracker tracker)` Request flush on this region.
`private void`	`requestFlush0(FlushLifeCycleTracker tracker)`
`private void`	`requestFlushIfNeeded()`
`protected void`	`restoreEdit(HStore s, Cell cell, MemStoreSizing memstoreAccounting)` Used by tests
`(package private) void`	`rewriteCellTags(Map<byte[],List<Cell>> familyMap, Mutation m)` Possibly rewrite incoming cell tags.
`static boolean`	`rowIsInRange(RegionInfo info, byte[] row)` Determines if the specified row is within the row range specified by the specified RegionInfo
`static boolean`	`rowIsInRange(RegionInfo info, byte[] row, int offset, short length)`
`void`	`setBlockCache(BlockCache blockCache)` Only used for unit test which doesn't start region server.
`void`	`setClosing(boolean closing)` Exposed for some very specific unit tests.
`(package private) org.apache.hadoop.hbase.shaded.protobuf.generated.ClusterStatusProtos.RegionLoad.Builder`	`setCompleteSequenceId(org.apache.hadoop.hbase.shaded.protobuf.generated.ClusterStatusProtos.RegionLoad.Builder regionLoadBldr)`
`void`	`setCoprocessorHost(RegionCoprocessorHost coprocessorHost)`
`(package private) void`	`setHTableSpecificConf()`
`void`	`setMobFileCache(MobFileCache mobFileCache)` Only used for unit test which doesn't start region server.
`void`	`setReadsEnabled(boolean readsEnabled)`
`void`	`setRestoredRegion(boolean restoredRegion)`
`(package private) void`	`setTableDescriptor(TableDescriptor desc)`
`void`	`setTimeoutForWriteLock(long timeoutForWriteLock)` The `doClose(boolean, org.apache.hadoop.hbase.monitoring.MonitoredTask)` will block forever if someone tries proving the dead lock via the unit test.
`(package private) boolean`	`shouldFlush(StringBuilder whyFlush)` Should the memstore be flushed now
`(package private) boolean`	`shouldFlushStore(HStore 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, CellComparator 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`	`sync(long txid, Durability durability)` Calls sync with the given transaction ID
`(package private) void`	`throwException(String title, String regionName)`
`String`	`toString()`
`void`	`unblockUpdates()`
`private static void`	`updateCellTimestamps(Iterable<List<Cell>> cellItr, byte[] now)` Replace any cell timestamps set to `HConstants.LATEST_TIMESTAMP` provided current timestamp.
`(package private) void`	`updateDeleteLatestVersionTimestamp(Cell cell, Get get, int count, byte[] byteNow)`
`private void`	`updateSequenceId(Iterable<List<Cell>> cellItr, long sequenceId)`
`void`	`waitForFlushes()` Wait for all current flushes of the region to complete
`boolean`	`waitForFlushes(long timeout)` Wait for all current flushes of the region to complete
`void`	`waitForFlushesAndCompactions()` Wait for all current flushes and compactions of the region to complete
`static void`	`warmupHRegion(RegionInfo info, TableDescriptor 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)`
`protected void`	`writeRegionOpenMarker(WAL wal, long openSeqId)`

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

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

- Field Detail
  - LOG
```
private static final org.slf4j.Logger LOG
```
  - LOAD_CFS_ON_DEMAND_CONFIG_KEY
```
public static final String LOAD_CFS_ON_DEMAND_CONFIG_KEY
```
    See Also:
    
    Constant Field Values
  - HBASE_MAX_CELL_SIZE_KEY
```
public static final String HBASE_MAX_CELL_SIZE_KEY
```
    See Also:
    
    Constant Field Values
  - DEFAULT_MAX_CELL_SIZE
```
public static final int DEFAULT_MAX_CELL_SIZE
```
    See Also:
    
    Constant Field Values
  - 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.
  - HBASE_REGIONSERVER_MINIBATCH_SIZE
```
public static final String HBASE_REGIONSERVER_MINIBATCH_SIZE
```
    See Also:
    
    Constant Field Values
  - DEFAULT_HBASE_REGIONSERVER_MINIBATCH_SIZE
```
public static final int DEFAULT_HBASE_REGIONSERVER_MINIBATCH_SIZE
```
    See Also:
    
    Constant Field Values
  - WAL_HSYNC_CONF_KEY
```
public static final String WAL_HSYNC_CONF_KEY
```
    See Also:
    
    Constant Field Values
  - DEFAULT_WAL_HSYNC
```
public static final boolean DEFAULT_WAL_HSYNC
```
    See Also:
    
    Constant Field Values
  - 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
```
  - lockedRows
```
private final ConcurrentHashMap<HashedBytes,HRegion.RowLockContext> lockedRows
```
  - stores
```
protected final Map<byte[],HStore> stores
```
  - coprocessorServiceHandlers
```
private Map<String,com.google.protobuf.Service> coprocessorServiceHandlers
```
  - memStoreSizing
```
private final MemStoreSizing memStoreSizing
```
  - regionServicesForStores
```
RegionServicesForStores regionServicesForStores
```
  - numMutationsWithoutWAL
```
final LongAdder numMutationsWithoutWAL
```
  - dataInMemoryWithoutWAL
```
final LongAdder dataInMemoryWithoutWAL
```
  - checkAndMutateChecksPassed
```
final LongAdder checkAndMutateChecksPassed
```
  - checkAndMutateChecksFailed
```
final LongAdder checkAndMutateChecksFailed
```
  - readRequestsCount
```
final LongAdder readRequestsCount
```
  - filteredReadRequestsCount
```
final LongAdder filteredReadRequestsCount
```
  - writeRequestsCount
```
final LongAdder writeRequestsCount
```
  - blockedRequestsCount
```
private final LongAdder blockedRequestsCount
```
  - compactionsFinished
```
final LongAdder compactionsFinished
```
  - compactionsFailed
```
final LongAdder compactionsFailed
```
  - compactionNumFilesCompacted
```
final LongAdder compactionNumFilesCompacted
```
  - compactionNumBytesCompacted
```
final LongAdder compactionNumBytesCompacted
```
  - compactionsQueued
```
final LongAdder compactionsQueued
```
  - flushesQueued
```
final LongAdder flushesQueued
```
  - blockCache
```
private BlockCache blockCache
```
  - mobFileCache
```
private MobFileCache mobFileCache
```
  - 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
```
  - rowLockWaitDuration
```
private final int rowLockWaitDuration
```
  - DEFAULT_ROWLOCK_WAIT_DURATION
```
static final int DEFAULT_ROWLOCK_WAIT_DURATION
```
    See Also:
    
    Constant Field Values
  - regionDir
```
private org.apache.hadoop.fs.Path regionDir
```
  - walFS
```
private org.apache.hadoop.fs.FileSystem walFS
```
  - isRestoredRegion
```
private boolean isRestoredRegion
```
  - 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
```
  - maxCellSize
```
final long maxCellSize
```
  - miniBatchSize
```
private final int miniBatchSize
```
  - 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 enLongAddered 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
  - configurationManager
```
private volatile ConfigurationManager configurationManager
```
  - timeoutForWriteLock
```
private volatile Long timeoutForWriteLock
```
  - writestate
```
final HRegion.WriteState writestate
```
  - memstoreFlushSize
```
long memstoreFlushSize
```
  - timestampSlop
```
final long timestampSlop
```
  - rowProcessorTimeout
```
final long rowProcessorTimeout
```
  - lastStoreFlushTimeMap
```
private final ConcurrentMap<HStore,Long> lastStoreFlushTimeMap
```
  - rsServices
```
final RegionServerServices rsServices
```
  - rsAccounting
```
private RegionServerAccounting rsAccounting
```
  - flushCheckInterval
```
private long flushCheckInterval
```
  - flushPerChanges
```
private long flushPerChanges
```
  - blockingMemStoreSize
```
private long blockingMemStoreSize
```
  - 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 TableDescriptor htableDescriptor
```
  - splitPolicy
```
private RegionSplitPolicy splitPolicy
```
  - flushPolicy
```
private FlushPolicy flushPolicy
```
  - metricsRegion
```
private final MetricsRegion metricsRegion
```
  - metricsRegionWrapper
```
private final MetricsRegionWrapperImpl metricsRegionWrapper
```
  - regionDurability
```
private final Durability regionDurability
```
  - regionStatsEnabled
```
private final boolean regionStatsEnabled
```
  - replicationScope
```
private final NavigableMap<byte[],Integer> replicationScope
```
  - storeHotnessProtector
```
private final StoreHotnessProtector storeHotnessProtector
```
  - 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,
                           RegionInfo regionInfo,
                           TableDescriptor htd,
                           RegionServerServices rsServices)
```
    Deprecated. Use other constructors.
    
    HRegion constructor. This constructor should only be used for testing and extensions. Instances of HRegion should be instantiated with the createHRegion(org.apache.hadoop.hbase.client.RegionInfo, org.apache.hadoop.fs.Path, org.apache.hadoop.conf.Configuration, org.apache.hadoop.hbase.client.TableDescriptor, org.apache.hadoop.hbase.wal.WAL, boolean) or openHRegion(org.apache.hadoop.hbase.client.RegionInfo, org.apache.hadoop.hbase.client.TableDescriptor, org.apache.hadoop.hbase.wal.WAL, org.apache.hadoop.conf.Configuration) method.
    
    Parameters:
    
    tableDir - qualified path of directory where region should be located, usually the table directory.
    
    wal - The WAL is the outbound log for any updates to the HRegion The wal file is a logfile from the previous execution that's custom-computed for this HRegion. The HRegionServer computes and sorts the appropriate wal info for this HRegion. If there is a previous wal file (implying that the HRegion has been written-to before), then read it from the supplied path.
    
    fs - is the filesystem.
    
    confParam - is global configuration settings.
    
    regionInfo - - RegionInfo that describes the region is new), then read them from the supplied path.
    
    htd - the table descriptor
    
    rsServices - reference to RegionServerServices or null
  - HRegion
```
public HRegion(HRegionFileSystem fs,
               WAL wal,
               org.apache.hadoop.conf.Configuration confParam,
               TableDescriptor htd,
               RegionServerServices rsServices)
```
    HRegion constructor. This constructor should only be used for testing and extensions. Instances of HRegion should be instantiated with the createHRegion(org.apache.hadoop.hbase.client.RegionInfo, org.apache.hadoop.fs.Path, org.apache.hadoop.conf.Configuration, org.apache.hadoop.hbase.client.TableDescriptor, org.apache.hadoop.hbase.wal.WAL, boolean) or openHRegion(org.apache.hadoop.hbase.client.RegionInfo, org.apache.hadoop.hbase.client.TableDescriptor, org.apache.hadoop.hbase.wal.WAL, org.apache.hadoop.conf.Configuration) method.
    
    Parameters:
    
    fs - is the filesystem.
    
    wal - The WAL is the outbound log for any updates to the HRegion The wal file is a logfile from the previous execution that's custom-computed for this HRegion. The HRegionServer computes and sorts the appropriate wal info for this HRegion. If there is a previous wal file (implying that the HRegion has been written-to before), then read it from the supplied path.
    
    confParam - is global configuration settings.
    
    htd - the table descriptor
    
    rsServices - reference to RegionServerServices or null
- Method Detail
  - setRestoredRegion
```
public void setRestoredRegion(boolean restoredRegion)
```
  - getSmallestReadPoint
```
public long getSmallestReadPoint()
```
    Returns:
    
    The smallest mvcc readPoint across all the scanners in this region. Writes older than this readPoint, are included in every read operation.
  - 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
```
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
  - initializeStores
```
private long initializeStores(CancelableProgressable reporter,
                              MonitoredTask status,
                              boolean warmup)
                       throws IOException
```
    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
```
protected 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.
  - blockUpdates
```
public void blockUpdates()
```
  - unblockUpdates
```
public void unblockUpdates()
```
  - getHDFSBlocksDistribution
```
public HDFSBlocksDistribution getHDFSBlocksDistribution()
```
  - computeHDFSBlocksDistribution
```
public static HDFSBlocksDistribution computeHDFSBlocksDistribution(org.apache.hadoop.conf.Configuration conf,
                                                                   TableDescriptor tableDescriptor,
                                                                   RegionInfo regionInfo)
                                                            throws IOException
```
    This is a helper function to compute HDFS block distribution on demand
    
    Parameters:
    
    conf - configuration
    
    tableDescriptor - TableDescriptor of the table
    
    regionInfo - encoded name of the region
    
    Returns:
    
    The HDFS blocks distribution for the given region.
    
    Throws:
    
    IOException
  - computeHDFSBlocksDistribution
```
public static HDFSBlocksDistribution computeHDFSBlocksDistribution(org.apache.hadoop.conf.Configuration conf,
                                                                   TableDescriptor tableDescriptor,
                                                                   RegionInfo regionInfo,
                                                                   org.apache.hadoop.fs.Path tablePath)
                                                            throws IOException
```
    This is a helper function to compute HDFS block distribution on demand
    
    Parameters:
    
    conf - configuration
    
    tableDescriptor - TableDescriptor of the table
    
    regionInfo - encoded name of the region
    
    tablePath - the table directory
    
    Returns:
    
    The HDFS blocks distribution for the given region.
    
    Throws:
    
    IOException
  - incMemStoreSize
```
void incMemStoreSize(MemStoreSize mss)
```
    Increase the size of mem store in this region and the size of global mem store
  - incMemStoreSize
```
void incMemStoreSize(long dataSizeDelta,
                     long heapSizeDelta,
                     long offHeapSizeDelta,
                     int cellsCountDelta)
```
  - decrMemStoreSize
```
void decrMemStoreSize(MemStoreSize mss)
```
  - decrMemStoreSize
```
void decrMemStoreSize(long dataSizeDelta,
                      long heapSizeDelta,
                      long offHeapSizeDelta,
                      int cellsCountDelta)
```
  - checkNegativeMemStoreDataSize
```
private void checkNegativeMemStoreDataSize(long memStoreDataSize,
                                           long delta)
```
  - getRegionInfo
```
public RegionInfo 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
  - getFilteredReadRequestsCount
```
public long getFilteredReadRequestsCount()
```
    Specified by:
    
    getFilteredReadRequestsCount in interface Region
    
    Returns:
    
    filtered read requests count for this region
  - getWriteRequestsCount
```
public long getWriteRequestsCount()
```
    Specified by:
    
    getWriteRequestsCount in interface Region
    
    Returns:
    
    write request count for this region
  - getMemStoreDataSize
```
public long getMemStoreDataSize()
```
    Specified by:
    
    getMemStoreDataSize in interface Region
    
    Returns:
    
    memstore size for this region, in bytes. It just accounts data size of cells added to the memstores of this Region. Means size in bytes for key, value and tags within Cells. It wont consider any java heap overhead for the cell objects or any other.
  - getMemStoreHeapSize
```
public long getMemStoreHeapSize()
```
    Specified by:
    
    getMemStoreHeapSize in interface Region
    
    Returns:
    
    memstore heap size for this region, in bytes. It accounts data size of cells added to the memstores of this Region, as well as java heap overhead for the cell objects or any other.
  - getMemStoreOffHeapSize
```
public long getMemStoreOffHeapSize()
```
    Specified by:
    
    getMemStoreOffHeapSize in interface Region
    
    Returns:
    
    memstore off-heap size for this region, in bytes. It accounts data size of cells added to the memstores of this Region, as well as overhead for the cell objects or any other that is allocated off-heap.
  - getRegionServicesForStores
```
public RegionServicesForStores getRegionServicesForStores()
```
    Returns:
    
    store services for this region, to access services required by store level needs
  - getNumMutationsWithoutWAL
```
public long getNumMutationsWithoutWAL()
```
    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()
```
  - 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
  - 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()
```
    Specified by:
    
    isSplittable in interface Region
    
    Returns:
    
    true if region is splittable
  - isMergeable
```
public boolean isMergeable()
```
    Specified by:
    
    isMergeable in interface Region
    
    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)
```
    Returns:
    
    readpoint considering given IsolationLevel. Pass null for default
  - isLoadingCfsOnDemandDefault
```
public boolean isLoadingCfsOnDemandDefault()
```
  - close
```
public Map<byte[],List<HStoreFile>> close()
                                   throws IOException
```
    Close down this HRegion. Flush the cache, shut down each HStore, don't service any more calls.
    This method could take some time to execute, so don't call it from a time-sensitive thread.
    
    Returns:
    
    Vector of all the storage files that the HRegion's component HStores make use of. It's a list of all StoreFile objects. Returns empty vector if already closed and null if judged that it should not close.
    
    Throws:
    
    IOException - e
    
    DroppedSnapshotException - Thrown when replay of wal is required because a Snapshot was not properly persisted. The region is put in closing mode, and the caller MUST abort after this.
  - close
```
public Map<byte[],List<HStoreFile>> close(boolean abort)
                                   throws IOException
```
    Close down this HRegion. Flush the cache unless abort parameter is true, Shut down each HStore, don't service any more calls. This method could take some time to execute, so don't call it from a time-sensitive thread.
    
    Parameters:
    
    abort - true if server is aborting (only during testing)
    
    Returns:
    
    Vector of all the storage files that the HRegion's component HStores make use of. It's a list of StoreFile objects. Can be null if we are not to close at this time or we are already closed.
    
    Throws:
    
    IOException - e
    
    DroppedSnapshotException - Thrown when replay of wal is required because a Snapshot was not properly persisted. The region is put in closing mode, and the caller MUST abort after this.
  - setClosing
```
public void setClosing(boolean closing)
```
    Exposed for some very specific unit tests.
  - setTimeoutForWriteLock
```
public void setTimeoutForWriteLock(long timeoutForWriteLock)
```
    The doClose(boolean, org.apache.hadoop.hbase.monitoring.MonitoredTask) will block forever if someone tries proving the dead lock via the unit test. Instead of blocking, the doClose(boolean, org.apache.hadoop.hbase.monitoring.MonitoredTask) will throw exception if you set the timeout.
    
    Parameters:
    
    timeoutForWriteLock - the second time to wait for the write lock in doClose(boolean, org.apache.hadoop.hbase.monitoring.MonitoredTask)
  - doClose
```
private Map<byte[],List<HStoreFile>> doClose(boolean abort,
                                             MonitoredTask status)
                                      throws IOException
```
    Throws:
    
    IOException
  - waitForFlushesAndCompactions
```
public void waitForFlushesAndCompactions()
```
    Wait for all current flushes and compactions of the region to complete
  - waitForFlushes
```
public void waitForFlushes()
```
    Wait for all current flushes of the region to complete
  - waitForFlushes
```
public boolean waitForFlushes(long timeout)
```
    Description copied from interface: Region
    
    Wait for all current flushes of the region to complete
    
    Specified by:
    
    waitForFlushes in interface Region
    
    Parameters:
    
    timeout - The maximum time to wait in milliseconds.
    
    Returns:
    
    False when timeout elapsed but flushes are not over. True when flushes are over within max wait time period.
  - 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.
  - getTableDescriptor
```
public TableDescriptor getTableDescriptor()
```
    Specified by:
    
    getTableDescriptor in interface Region
    
    Returns:
    
    table descriptor for this region
  - setTableDescriptor
```
void setTableDescriptor(TableDescriptor desc)
```
  - getWAL
```
public WAL getWAL()
```
    Returns:
    
    WAL in use for this region
  - getBlockCache
```
public BlockCache getBlockCache()
```
  - setBlockCache
```
public void setBlockCache(BlockCache blockCache)
```
    Only used for unit test which doesn't start region server.
  - getMobFileCache
```
public MobFileCache getMobFileCache()
```
  - setMobFileCache
```
public void setMobFileCache(MobFileCache mobFileCache)
```
    Only used for unit test which doesn't start region server.
  - getSplitPolicy
```
public RegionSplitPolicy getSplitPolicy()
```
    Returns:
    
    split policy 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
  - getRegionWALFileSystem
```
HRegionWALFileSystem getRegionWALFileSystem()
                                     throws IOException
```
    Returns:
    
    the WAL HRegionFileSystem used by this region
    
    Throws:
    
    IOException
  - getWalFileSystem
```
org.apache.hadoop.fs.FileSystem getWalFileSystem()
                                          throws IOException
```
    Returns:
    
    the WAL FileSystem being used by this region
    
    Throws:
    
    IOException
  - getWALRegionDir
```
public org.apache.hadoop.fs.Path getWALRegionDir()
                                          throws IOException
```
    Returns:
    
    the Region directory under WALRootDirectory
    
    Throws:
    
    IOException - if there is an error getting WALRootDir
  - getEarliestFlushTimeForAllStores
```
public long getEarliestFlushTimeForAllStores()
```
    Specified by:
    
    getEarliestFlushTimeForAllStores in interface Region
    
    Returns:
    
    The earliest time a store in the region was flushed. All other stores in the region would have been flushed either at, or after this time.
  - getOldestHfileTs
```
public long getOldestHfileTs(boolean majorCompactionOnly)
                      throws IOException
```
    Description copied from interface: Region
    
    This can be used to determine the last time all files of this region were major compacted.
    
    Specified by:
    
    getOldestHfileTs in interface Region
    
    Parameters:
    
    majorCompactionOnly - Only consider HFile that are the result of major compaction
    
    Returns:
    
    the timestamp of the oldest HFile for all stores of this region
    
    Throws:
    
    IOException
  - setCompleteSequenceId
```
org.apache.hadoop.hbase.shaded.protobuf.generated.ClusterStatusProtos.RegionLoad.Builder setCompleteSequenceId(org.apache.hadoop.hbase.shaded.protobuf.generated.ClusterStatusProtos.RegionLoad.Builder regionLoadBldr)
```
  - doRegionCompactionPrep
```
protected void doRegionCompactionPrep()
                               throws IOException
```
    Do preparation for pending compaction.
    
    Throws:
    
    IOException
  - compact
```
public void compact(boolean majorCompaction)
             throws IOException
```
    Synchronously compact all stores in the region.
    This operation could block for a long time, so don't call it from a time-sensitive thread.
    Note that no locks are taken to prevent possible conflicts between compaction and splitting activities. The regionserver does not normally compact and split in parallel. However by calling this method you may introduce unexpected and unhandled concurrency. Don't do this unless you know what you are doing.
    
    Parameters:
    
    majorCompaction - True to force a major compaction regardless of thresholds
    
    Throws:
    
    IOException
  - compactStores
```
public void compactStores()
                   throws IOException
```
    This is a helper function that compact all the stores synchronously.
    It is used by utilities and testing
    
    Throws:
    
    IOException
  - compactStore
```
void compactStore(byte[] family,
                  ThroughputController throughputController)
           throws IOException
```
    This is a helper function that compact the given store.
    It is used by utilities and testing
    
    Throws:
    
    IOException
  - compact
```
public boolean compact(CompactionContext compaction,
                       HStore store,
                       ThroughputController throughputController)
                throws IOException
```
    Called by compaction thread and after region is opened to compact the HStores if necessary.
    This operation could block for a long time, so don't call it from a time-sensitive thread. Note that no locking is necessary at this level because compaction only conflicts with a region split, and that cannot happen because the region server does them sequentially and not in parallel.
    
    Parameters:
    
    compaction - Compaction details, obtained by requestCompaction()
    
    throughputController -
    
    Returns:
    
    whether the compaction completed
    
    Throws:
    
    IOException
  - compact
```
public boolean compact(CompactionContext compaction,
                       HStore store,
                       ThroughputController throughputController,
                       User user)
                throws IOException
```
    Throws:
    
    IOException
  - flush
```
public HRegion.FlushResult flush(boolean force)
                          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:
    
    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 HRegion.FlushResultImpl flushcache(boolean forceFlushAllStores,
                                          boolean writeFlushRequestWalMarker,
                                          FlushLifeCycleTracker tracker)
                                   throws IOException
```
    Flush the cache. When this method is called the cache will be flushed unless:
    1. the cache is empty
    2. the region is closed.
    3. a flush is already in progress
    4. writes are disabled
    This method may block for some time, so it should not be called from a time-sensitive thread.
    Parameters:
    
    forceFlushAllStores - whether we want to flush all stores
    
    writeFlushRequestWalMarker - whether to write the flush request marker to WAL
    
    tracker - used to track the life cycle of this flush
    
    Returns:
    
    whether the flush is success and whether the region needs compacting
    
    Throws:
    
    IOException - general io exceptions
    
    DroppedSnapshotException - Thrown when replay of wal is required because a Snapshot was not properly persisted. The region is put in closing mode, and the caller MUST abort after this.
  - shouldFlushStore
```
boolean shouldFlushStore(HStore 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 method will always returns true which will make a lot of flush requests.
  - shouldFlush
```
boolean shouldFlush(StringBuilder whyFlush)
```
    Should the memstore be flushed now
  - internalFlushcache
```
private HRegion.FlushResult internalFlushcache(MonitoredTask status)
                                        throws IOException
```
    Flushing all stores.
    
    Throws:
    
    IOException
    
    See Also:
    
    internalFlushcache(Collection, MonitoredTask, boolean, FlushLifeCycleTracker)
  - internalFlushcache
```
private HRegion.FlushResultImpl internalFlushcache(Collection<HStore> storesToFlush,
                                                   MonitoredTask status,
                                                   boolean writeFlushWalMarker,
                                                   FlushLifeCycleTracker tracker)
                                            throws IOException
```
    Flushing given stores.
    
    Throws:
    
    IOException
    
    See Also:
    
    internalFlushcache(WAL, long, Collection, MonitoredTask, boolean, FlushLifeCycleTracker)
  - internalFlushcache
```
protected HRegion.FlushResultImpl internalFlushcache(WAL wal,
                                                     long myseqid,
                                                     Collection<HStore> storesToFlush,
                                                     MonitoredTask status,
                                                     boolean writeFlushWalMarker,
                                                     FlushLifeCycleTracker tracker)
                                              throws IOException
```
    Flush the memstore. Flushing the memstore is a little tricky. We have a lot of updates in the memstore, all of which have also been written to the wal. We need to write those updates in the memstore out to disk, while being able to process reads/writes as much as possible during the flush operation.
    This method may block for some time. Every time you call it, we up the regions sequence id even if we don't flush; i.e. the returned region id will be at least one larger than the last edit applied to this region. The returned id does not refer to an actual edit. The returned id can be used for say installing a bulk loaded file just ahead of the last hfile that was the result of this flush, etc.
    
    Parameters:
    
    wal - Null if we're NOT to go via wal.
    
    myseqid - The seqid to use if wal is null writing out flush file.
    
    storesToFlush - The list of stores to flush.
    
    Returns:
    
    object describing the flush's state
    
    Throws:
    
    IOException - general io exceptions
    
    DroppedSnapshotException - Thrown when replay of WAL is required.
  - internalPrepareFlushCache
```
protected HRegion.PrepareFlushResult internalPrepareFlushCache(WAL wal,
                                                               long myseqid,
                                                               Collection<HStore> storesToFlush,
                                                               MonitoredTask status,
                                                               boolean writeFlushWalMarker,
                                                               FlushLifeCycleTracker tracker)
                                                        throws IOException
```
    Throws:
    
    IOException
  - logFatLineOnFlush
```
private void logFatLineOnFlush(Collection<HStore> storesToFlush,
                               long sequenceId)
```
    Utility method broken out of internalPrepareFlushCache so that method is smaller.
  - doAbortFlushToWAL
```
private void doAbortFlushToWAL(WAL wal,
                               long flushOpSeqId,
                               Map<byte[],List<org.apache.hadoop.fs.Path>> committedFiles)
```
  - doSyncOfUnflushedWALChanges
```
private static void doSyncOfUnflushedWALChanges(WAL wal,
                                                RegionInfo hri)
                                         throws IOException
```
    Sync unflushed WAL changes. See HBASE-8208 for details
    
    Throws:
    
    IOException
  - isAllFamilies
```
private boolean isAllFamilies(Collection<HStore> 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 HRegion.FlushResultImpl internalFlushCacheAndCommit(WAL wal,
                                                              MonitoredTask status,
                                                              HRegion.PrepareFlushResult prepareResult,
                                                              Collection<HStore> 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
  - getScanner
```
public HRegion.RegionScannerImpl getScanner(Scan scan)
                                     throws IOException
```
    Description copied from interface: Region
    
    Return an iterator that scans over the HRegion, returning the indicated columns and rows specified by the Scan.
    This Iterator must be closed by the caller.
    
    Specified by:
    
    getScanner in interface Region
    
    Parameters:
    
    scan - configured Scan
    
    Returns:
    
    RegionScanner
    
    Throws:
    
    IOException - read exceptions
  - getScanner
```
public HRegion.RegionScannerImpl getScanner(Scan scan,
                                            List<KeyValueScanner> additionalScanners)
                                     throws IOException
```
    Description copied from interface: Region
    
    Return an iterator that scans over the HRegion, returning the indicated columns and rows specified by the Scan. The scanner will also include the additional scanners passed along with the scanners for the specified Scan instance. Should be careful with the usage to pass additional scanners only within this Region
    This Iterator must be closed by the caller.
    
    Specified by:
    
    getScanner in interface Region
    
    Parameters:
    
    scan - configured Scan
    
    additionalScanners - Any additional scanners to be used
    
    Returns:
    
    RegionScanner
    
    Throws:
    
    IOException - read exceptions
  - getScanner
```
private HRegion.RegionScannerImpl getScanner(Scan scan,
                                             List<KeyValueScanner> additionalScanners,
                                             long nonceGroup,
                                             long nonce)
                                      throws IOException
```
    Throws:
    
    IOException
  - instantiateRegionScanner
```
protected RegionScanner instantiateRegionScanner(Scan scan,
                                                 List<KeyValueScanner> additionalScanners)
                                          throws IOException
```
    Throws:
    
    IOException
  - instantiateRegionScanner
```
protected HRegion.RegionScannerImpl instantiateRegionScanner(Scan scan,
                                                             List<KeyValueScanner> additionalScanners,
                                                             long nonceGroup,
                                                             long nonce)
                                                      throws IOException
```
    Throws:
    
    IOException
  - prepareDelete
```
public void prepareDelete(Delete delete)
                   throws IOException
```
    Prepare a delete for a row mutation processor
    
    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
```
    Set up correct timestamps in the KVs in Delete object.
    Caller should have the row and region locks.
    
    Parameters:
    
    mutation -
    
    familyMap -
    
    byteNow -
    
    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
```
    Throws:
    
    IOException
  - batchMutate
```
public OperationStatus[] batchMutate(Mutation[] mutations,
                                     boolean atomic,
                                     long nonceGroup,
                                     long nonce)
                              throws IOException
```
    Throws:
    
    IOException
  - batchMutate
```
public OperationStatus[] batchMutate(Mutation[] mutations)
                              throws IOException
```
    Description copied from interface: Region
    
    Perform a batch of mutations.
    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
  - batchReplay
```
public OperationStatus[] batchReplay(WALSplitUtil.MutationReplay[] mutations,
                                     long replaySeqId)
                              throws IOException
```
    Throws:
    
    IOException
  - batchMutate
```
OperationStatus[] batchMutate(HRegion.BatchOperation<?> batchOp)
                       throws IOException
```
    Perform a batch of mutations. It supports only Put and Delete mutations and will ignore other types passed. Operations in a batch are stored with highest durability specified of for all operations in a batch, except for Durability.SKIP_WAL.
    This function is called from batchReplay(WALSplitUtil.MutationReplay[], long) with HRegion.ReplayBatchOperation instance and batchMutate(Mutation[], long, long) with HRegion.MutationBatchOperation instance as an argument. As the processing of replay batch and mutation batch is very similar, lot of code is shared by providing generic methods in base class HRegion.BatchOperation. The logic for this method and doMiniBatchMutate(BatchOperation) is implemented using methods in base class which are overridden by derived classes to implement special behavior.
    
    Parameters:
    
    batchOp - contains the list of mutations
    
    Returns:
    
    an array of OperationStatus which internally contains the OperationStatusCode and the exceptionMessage if any.
    
    Throws:
    
    IOException - if an IO problem is encountered
  - doMiniBatchMutate
```
private void doMiniBatchMutate(HRegion.BatchOperation<?> batchOp)
                        throws IOException
```
    Called to do a piece of the batch that came in to batchMutate(Mutation[], long, long) In here we also handle replay of edits on region recover. Also gets change in size brought about by applying batchOp.
    
    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,
                              CompareOperator op,
                              ByteArrayComparable comparator,
                              TimeRange timeRange,
                              Mutation mutation)
                       throws IOException
```
    Description copied from interface: Region
    
    Atomically checks if a row/family/qualifier value matches the expected value and if it does, it performs the mutation. If the passed value is null, the lack of column value (ie: non-existence) is used. See checkAndRowMutate to do many checkAndPuts at a time on a single row.
    
    Specified by:
    
    checkAndMutate in interface Region
    
    Parameters:
    
    row - to check
    
    family - column family to check
    
    qualifier - column qualifier to check
    
    op - the comparison operator
    
    comparator - the expected value
    
    timeRange - time range to check
    
    mutation - data to put if check succeeds
    
    Returns:
    
    true if mutation was applied, false otherwise
    
    Throws:
    
    IOException
  - checkAndRowMutate
```
public boolean checkAndRowMutate(byte[] row,
                                 byte[] family,
                                 byte[] qualifier,
                                 CompareOperator op,
                                 ByteArrayComparable comparator,
                                 TimeRange timeRange,
                                 RowMutations rm)
                          throws IOException
```
    Description copied from interface: Region
    
    Atomically checks if a row/family/qualifier value matches the expected values and if it does, it performs the row mutations. If the passed value is null, the lack of column value (ie: non-existence) is used. Use to do many mutations on a single row. Use checkAndMutate to do one checkAndMutate at a time.
    
    Specified by:
    
    checkAndRowMutate in interface Region
    
    Parameters:
    
    row - to check
    
    family - column family to check
    
    qualifier - column qualifier to check
    
    op - the comparison operator
    
    comparator - the expected value
    
    timeRange - time range to check
    
    rm - data to put if check succeeds
    
    Returns:
    
    true if mutations were applied, false otherwise
    
    Throws:
    
    IOException
  - doCheckAndRowMutate
```
private boolean doCheckAndRowMutate(byte[] row,
                                    byte[] family,
                                    byte[] qualifier,
                                    CompareOperator op,
                                    ByteArrayComparable comparator,
                                    TimeRange timeRange,
                                    RowMutations rowMutations,
                                    Mutation mutation)
                             throws IOException
```
    checkAndMutate and checkAndRowMutate are 90% the same. Rather than copy/paste, below has switches in the few places where there is deviation.
    
    Throws:
    
    IOException
  - checkMutationType
```
private void checkMutationType(Mutation mutation,
                               byte[] row)
                        throws DoNotRetryIOException
```
    Throws:
    
    DoNotRetryIOException
  - matches
```
private boolean matches(CompareOperator op,
                        int compareResult)
```
  - doBatchMutate
```
private void doBatchMutate(Mutation mutation)
                    throws IOException
```
    Throws:
    
    IOException
  - addRegionToSnapshot
```
public void addRegionToSnapshot(org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription desc,
                                ForeignExceptionSnare exnSnare)
                         throws IOException
```
    Complete taking the snapshot on the region. Writes the region info and adds references to the working snapshot directory. TODO for api consistency, consider adding another version with no ForeignExceptionSnare arg. (In the future other cancellable HRegion methods could eventually add a ForeignExceptionSnare, or we could do something fancier).
    
    Parameters:
    
    desc - snapshot description object
    
    exnSnare - ForeignExceptionSnare that captures external exceptions in case we need to bail out. This is allowed to be null and will just be ignored in that case.
    
    Throws:
    
    IOException - if there is an external or internal error causing the snapshot to fail
  - updateSequenceId
```
private void updateSequenceId(Iterable<List<Cell>> cellItr,
                              long sequenceId)
                       throws IOException
```
    Throws:
    
    IOException
  - updateCellTimestamps
```
private static void updateCellTimestamps(Iterable<List<Cell>> cellItr,
                                         byte[] now)
                                  throws IOException
```
    Replace any cell timestamps set to HConstants.LATEST_TIMESTAMP provided current timestamp.
    
    Parameters:
    
    cellItr -
    
    now -
    
    Throws:
    
    IOException
  - rewriteCellTags
```
void rewriteCellTags(Map<byte[],List<Cell>> familyMap,
                     Mutation m)
```
    Possibly rewrite incoming cell tags.
  - checkResources
```
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
```
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
  - applyToMemStore
```
private void applyToMemStore(HStore store,
                             List<Cell> cells,
                             boolean delta,
                             MemStoreSizing memstoreAccounting)
                      throws IOException
```
    Parameters:
    
    delta - If we are doing delta changes -- e.g. increment/append -- then this flag will be set; when set we will run operations that make sense in the increment/append scenario but that do not make sense otherwise.
    
    Throws:
    
    IOException
    
    See Also:
    
    applyToMemStore(HStore, Cell, MemStoreSizing)
  - applyToMemStore
```
private void applyToMemStore(HStore store,
                             Cell cell,
                             MemStoreSizing memstoreAccounting)
                      throws IOException
```
    Throws:
    
    IOException
    
    See Also:
    
    applyToMemStore(HStore, List, boolean, MemStoreSizing)
  - checkFamilies
```
public void checkFamilies(Collection<byte[]> families)
                   throws NoSuchColumnFamilyException
```
    Check the collection of families for validity.
    
    Parameters:
    
    families -
    
    Throws:
    
    NoSuchColumnFamilyException
  - checkTimestamps
```
public void checkTimestamps(Map<byte[],List<Cell>> familyMap,
                            long now)
                     throws FailedSanityCheckException
```
    Check the collection of families for valid timestamps
    
    Parameters:
    
    familyMap -
    
    now - current timestamp
    
    Throws:
    
    FailedSanityCheckException
  - isFlushSize
```
private boolean isFlushSize(MemStoreSize size)
```
  - replayRecoveredEditsIfAny
```
protected long replayRecoveredEditsIfAny(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
  - replayRecoveredEditsForPaths
```
private long replayRecoveredEditsForPaths(long minSeqIdForTheRegion,
                                          org.apache.hadoop.fs.FileSystem fs,
                                          NavigableSet<org.apache.hadoop.fs.Path> files,
                                          CancelableProgressable reporter,
                                          org.apache.hadoop.fs.Path regionDir)
                                   throws IOException
```
    Throws:
    
    IOException
  - replayRecoveredEdits
```
private long replayRecoveredEdits(org.apache.hadoop.fs.Path edits,
                                  Map<byte[],Long> maxSeqIdInStores,
                                  CancelableProgressable reporter,
                                  org.apache.hadoop.fs.FileSystem fs)
                           throws IOException
```
    Throws:
    
    IOException
  - replayWALCompactionMarker
```
void replayWALCompactionMarker(org.apache.hadoop.hbase.shaded.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.shaded.protobuf.generated.WALProtos.FlushDescriptor flush,
                          long replaySeqId)
                   throws IOException
```
    Throws:
    
    IOException
  - replayWALFlushStartMarker
```
HRegion.PrepareFlushResult replayWALFlushStartMarker(org.apache.hadoop.hbase.shaded.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.shaded.protobuf.generated.WALProtos.FlushDescriptor flush)
                         throws IOException
```
    Throws:
    
    IOException
  - replayFlushInStores
```
private void replayFlushInStores(org.apache.hadoop.hbase.shaded.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
  - dropMemStoreContents
```
public MemStoreSize dropMemStoreContents()
                                  throws IOException
```
    Be careful, this method will drop all data in the memstore of this region. Currently, this method is used to drop memstore to prevent memory leak when replaying recovered.edits while opening region.
    
    Throws:
    
    IOException
  - dropMemStoreContentsForSeqId
```
private MemStoreSize dropMemStoreContentsForSeqId(long seqId,
                                                  HStore 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 MemStoreSize doDropStoreMemStoreContentsForSeqId(HStore s,
                                                         long currentSeqId)
                                                  throws IOException
```
    Throws:
    
    IOException
  - replayWALFlushAbortMarker
```
private void replayWALFlushAbortMarker(org.apache.hadoop.hbase.shaded.protobuf.generated.WALProtos.FlushDescriptor flush)
```
  - replayWALFlushCannotFlushMarker
```
private void replayWALFlushCannotFlushMarker(org.apache.hadoop.hbase.shaded.protobuf.generated.WALProtos.FlushDescriptor flush,
                                             long replaySeqId)
```
  - getPrepareFlushResult
```
HRegion.PrepareFlushResult getPrepareFlushResult()
```
  - replayWALRegionEventMarker
```
void replayWALRegionEventMarker(org.apache.hadoop.hbase.shaded.protobuf.generated.WALProtos.RegionEventDescriptor regionEvent)
                         throws IOException
```
    Throws:
    
    IOException
  - replayWALBulkLoadEventMarker
```
void replayWALBulkLoadEventMarker(org.apache.hadoop.hbase.shaded.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 void restoreEdit(HStore s,
                           Cell cell,
                           MemStoreSizing memstoreAccounting)
```
    Used by tests
    
    Parameters:
    
    s - Store to add edit too.
    
    cell - Cell to add.
  - isZeroLengthThenDelete
```
private static boolean isZeroLengthThenDelete(org.apache.hadoop.fs.FileSystem fs,
                                              org.apache.hadoop.fs.Path p)
                                       throws IOException
```
    Parameters:
    
    p - File to check.
    
    Returns:
    
    True if file was zero-length (and if so, we'll delete it in here).
    
    Throws:
    
    IOException
  - instantiateHStore
```
protected HStore instantiateHStore(ColumnFamilyDescriptor family,
                                   boolean warmup)
                            throws IOException
```
    Throws:
    
    IOException
  - getStore
```
public HStore getStore(byte[] column)
```
    Description copied from interface: Region
    
    Return the Store for the given family
    Use with caution. Exposed for use of fixup utilities.
    
    Specified by:
    
    getStore in interface Region
    
    Returns:
    
    the Store for the given family
  - getStore
```
private HStore 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<HStore> getStores()
```
    Description copied from interface: Region
    
    Return the list of Stores managed by this region
    Use with caution. Exposed for use of fixup utilities.
    
    Specified by:
    
    getStores in interface Region
    
    Returns:
    
    a list of the Stores managed by this region
  - getStoreFileList
```
public List<String> getStoreFileList(byte[][] columns)
                              throws IllegalArgumentException
```
    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
  - getRowLock
```
public Region.RowLock getRowLock(byte[] row,
                                 boolean readLock)
                          throws IOException
```
    Description copied from interface: Region
    
    Get a row lock for the specified row. All locks are reentrant. Before calling this function make sure that a region operation has already been started (the calling thread has already acquired the region-close-guard lock).
    The obtained locks should be released after use by Region.RowLock.release()
    NOTE: the boolean passed here has changed. It used to be a boolean that stated whether or not to wait on the lock. Now it is whether it an exclusive lock is requested.
    
    Specified by:
    
    getRowLock in interface Region
    
    Parameters:
    
    row - The row actions will be performed against
    
    readLock - is the lock reader or writer. True indicates that a non-exclusive lock is requested
    
    Throws:
    
    IOException
    
    See Also:
    
    Region.startRegionOperation(), Region.startRegionOperation(Operation)
  - getRowLockInternal
```
protected Region.RowLock getRowLockInternal(byte[] row,
                                            boolean readLock,
                                            Region.RowLock prevRowLock)
                                     throws IOException
```
    Throws:
    
    IOException
  - releaseRowLocks
```
private void releaseRowLocks(List<Region.RowLock> rowLocks)
```
  - getReadLockCount
```
public int getReadLockCount()
```
  - 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 (column family, hfilePath)
  - bulkLoadHFiles
```
public Map<byte[],List<org.apache.hadoop.fs.Path>> bulkLoadHFiles(Collection<Pair<byte[],String>> familyPaths,
                                                                  boolean assignSeqId,
                                                                  HRegion.BulkLoadListener bulkLoadListener)
                                                           throws IOException
```
    Attempts to atomically load a group of hfiles. This is critical for loading rows with multiple column families atomically.
    
    Parameters:
    
    familyPaths - List of Pair<byte[] column family, String hfilePath>
    
    bulkLoadListener - Internal hooks enabling massaging/preparation of a file about to be bulk loaded
    
    assignSeqId -
    
    Returns:
    
    Map from family to List of store file paths if successful, null if failed recoverably
    
    Throws:
    
    IOException - if failed unrecoverably.
  - bulkLoadHFiles
```
public Map<byte[],List<org.apache.hadoop.fs.Path>> bulkLoadHFiles(Collection<Pair<byte[],String>> familyPaths,
                                                                  boolean assignSeqId,
                                                                  HRegion.BulkLoadListener bulkLoadListener,
                                                                  boolean copyFile,
                                                                  List<String> clusterIds,
                                                                  boolean replicate)
                                                           throws IOException
```
    Attempts to atomically load a group of hfiles. This is critical for loading rows with multiple column families atomically.
    
    Parameters:
    
    familyPaths - List of Pair<byte[] column family, String hfilePath>
    
    assignSeqId -
    
    bulkLoadListener - Internal hooks enabling massaging/preparation of a file about to be bulk loaded
    
    copyFile - always copy hfiles if true
    
    clusterIds - ids from clusters that had already handled the given bulkload event.
    
    Returns:
    
    Map from family to List of store file paths if successful, null if failed recoverably
    
    Throws:
    
    IOException - if failed unrecoverably.
  - equals
```
public boolean equals(Object o)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - newHRegion
```
public static HRegion newHRegion(org.apache.hadoop.fs.Path tableDir,
                                 WAL wal,
                                 org.apache.hadoop.fs.FileSystem fs,
                                 org.apache.hadoop.conf.Configuration conf,
                                 RegionInfo regionInfo,
                                 TableDescriptor htd,
                                 RegionServerServices rsServices)
```
    A utility method to create new instances of HRegion based on the HConstants.REGION_IMPL configuration property.
    
    Parameters:
    
    tableDir - qualified path of directory where region should be located, usually the table directory.
    
    wal - The WAL is the outbound log for any updates to the HRegion The wal file is a logfile from the previous execution that's custom-computed for this HRegion. The HRegionServer computes and sorts the appropriate wal info for this HRegion. If there is a previous file (implying that the HRegion has been written-to before), then read it from the supplied path.
    
    fs - is the filesystem.
    
    conf - is global configuration settings.
    
    regionInfo - - RegionInfo that describes the region is new), then read them from the supplied path.
    
    htd - the table descriptor
    
    Returns:
    
    the new instance
  - createHRegion
```
public static HRegion createHRegion(RegionInfo info,
                                    org.apache.hadoop.fs.Path rootDir,
                                    org.apache.hadoop.conf.Configuration conf,
                                    TableDescriptor hTableDescriptor,
                                    WAL wal,
                                    boolean initialize)
                             throws IOException
```
    Convenience method creating new HRegions. Used by createTable.
    
    Parameters:
    
    info - Info for region to create.
    
    rootDir - Root directory for HBase instance
    
    wal - shared WAL
    
    initialize - - true to initialize the region
    
    Returns:
    
    new HRegion
    
    Throws:
    
    IOException
  - createRegionDir
```
public static HRegionFileSystem createRegionDir(org.apache.hadoop.conf.Configuration configuration,
                                                RegionInfo ri,
                                                org.apache.hadoop.fs.Path rootDir)
                                         throws IOException
```
    Create the region directory in the filesystem.
    
    Throws:
    
    IOException
  - createHRegion
```
public static HRegion createHRegion(RegionInfo info,
                                    org.apache.hadoop.fs.Path rootDir,
                                    org.apache.hadoop.conf.Configuration conf,
                                    TableDescriptor hTableDescriptor,
                                    WAL wal)
                             throws IOException
```
    Throws:
    
    IOException
  - openHRegion
```
public static HRegion openHRegion(RegionInfo info,
                                  TableDescriptor htd,
                                  WAL wal,
                                  org.apache.hadoop.conf.Configuration conf)
                           throws IOException
```
    Open a Region.
    
    Parameters:
    
    info - Info for region to be opened.
    
    wal - WAL for region to use. This method will call WAL#setSequenceNumber(long) passing the result of the call to HRegion#getMinSequenceId() to ensure the wal id is properly kept up. HRegionStore does this every time it opens a new region.
    
    Returns:
    
    new HRegion
    
    Throws:
    
    IOException
  - openHRegion
```
public static HRegion openHRegion(RegionInfo info,
                                  TableDescriptor htd,
                                  WAL wal,
                                  org.apache.hadoop.conf.Configuration conf,
                                  RegionServerServices rsServices,
                                  CancelableProgressable reporter)
                           throws IOException
```
    Open a Region.
    
    Parameters:
    
    info - Info for region to be opened
    
    htd - the table descriptor
    
    wal - WAL for region to use. This method will call WAL#setSequenceNumber(long) passing the result of the call to HRegion#getMinSequenceId() to ensure the wal id is properly kept up. HRegionStore does this every time it opens a new region.
    
    conf - The Configuration object to use.
    
    rsServices - An interface we can request flushes against.
    
    reporter - An interface we can report progress against.
    
    Returns:
    
    new HRegion
    
    Throws:
    
    IOException
  - openHRegion
```
public static HRegion openHRegion(org.apache.hadoop.fs.Path rootDir,
                                  RegionInfo info,
                                  TableDescriptor htd,
                                  WAL wal,
                                  org.apache.hadoop.conf.Configuration conf)
                           throws IOException
```
    Open a Region.
    
    Parameters:
    
    rootDir - Root directory for HBase instance
    
    info - Info for region to be opened.
    
    htd - the table descriptor
    
    wal - WAL for region to use. This method will call WAL#setSequenceNumber(long) passing the result of the call to HRegion#getMinSequenceId() to ensure the wal id is properly kept up. HRegionStore does this every time it opens a new region.
    
    conf - The Configuration object to use.
    
    Returns:
    
    new HRegion
    
    Throws:
    
    IOException
  - openHRegion
```
public static HRegion openHRegion(org.apache.hadoop.fs.Path rootDir,
                                  RegionInfo info,
                                  TableDescriptor htd,
                                  WAL wal,
                                  org.apache.hadoop.conf.Configuration conf,
                                  RegionServerServices rsServices,
                                  CancelableProgressable reporter)
                           throws IOException
```
    Open a Region.
    
    Parameters:
    
    rootDir - Root directory for HBase instance
    
    info - Info for region to be opened.
    
    htd - the table descriptor
    
    wal - WAL for region to use. This method will call WAL#setSequenceNumber(long) passing the result of the call to HRegion#getMinSequenceId() to ensure the wal id is properly kept up. HRegionStore does this every time it opens a new region.
    
    conf - The Configuration object to use.
    
    rsServices - An interface we can request flushes against.
    
    reporter - An interface we can report progress against.
    
    Returns:
    
    new HRegion
    
    Throws:
    
    IOException
  - openHRegion
```
public static HRegion openHRegion(org.apache.hadoop.conf.Configuration conf,
                                  org.apache.hadoop.fs.FileSystem fs,
                                  org.apache.hadoop.fs.Path rootDir,
                                  RegionInfo info,
                                  TableDescriptor htd,
                                  WAL wal)
                           throws IOException
```
    Open a Region.
    
    Parameters:
    
    conf - The Configuration object to use.
    
    fs - Filesystem to use
    
    rootDir - Root directory for HBase instance
    
    info - Info for region to be opened.
    
    htd - the table descriptor
    
    wal - WAL for region to use. This method will call WAL#setSequenceNumber(long) passing the result of the call to HRegion#getMinSequenceId() to ensure the wal id is properly kept up. HRegionStore does this every time it opens a new region.
    
    Returns:
    
    new HRegion
    
    Throws:
    
    IOException
  - openHRegion
```
public static HRegion openHRegion(org.apache.hadoop.conf.Configuration conf,
                                  org.apache.hadoop.fs.FileSystem fs,
                                  org.apache.hadoop.fs.Path rootDir,
                                  RegionInfo info,
                                  TableDescriptor htd,
                                  WAL wal,
                                  RegionServerServices rsServices,
                                  CancelableProgressable reporter)
                           throws IOException
```
    Open a Region.
    
    Parameters:
    
    conf - The Configuration object to use.
    
    fs - Filesystem to use
    
    rootDir - Root directory for HBase instance
    
    info - Info for region to be opened.
    
    htd - the table descriptor
    
    wal - WAL for region to use. This method will call WAL#setSequenceNumber(long) passing the result of the call to HRegion#getMinSequenceId() to ensure the wal id is properly kept up. HRegionStore does this every time it opens a new region.
    
    rsServices - An interface we can request flushes against.
    
    reporter - An interface we can report progress against.
    
    Returns:
    
    new HRegion
    
    Throws:
    
    IOException
  - 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,
                                  RegionInfo info,
                                  TableDescriptor htd,
                                  WAL wal,
                                  RegionServerServices rsServices,
                                  CancelableProgressable reporter)
                           throws IOException
```
    Open a Region.
    
    Parameters:
    
    conf - The Configuration object to use.
    
    fs - Filesystem to use
    
    rootDir - Root directory for HBase instance
    
    info - Info for region to be opened.
    
    htd - the table descriptor
    
    wal - WAL for region to use. This method will call WAL#setSequenceNumber(long) passing the result of the call to HRegion#getMinSequenceId() to ensure the wal id is properly kept up. HRegionStore does this every time it opens a new region.
    
    rsServices - An interface we can request flushes against.
    
    reporter - An interface we can report progress against.
    
    Returns:
    
    new HRegion
    
    Throws:
    
    IOException
  - getReplicationScope
```
public NavigableMap<byte[],Integer> getReplicationScope()
```
  - openHRegion
```
public static HRegion openHRegion(HRegion other,
                                  CancelableProgressable reporter)
                           throws IOException
```
    Useful when reopening a closed region (normally for unit tests)
    
    Parameters:
    
    other - original object
    
    reporter - An interface we can report progress against.
    
    Returns:
    
    new HRegion
    
    Throws:
    
    IOException
  - openHRegion
```
public static Region openHRegion(Region other,
                                 CancelableProgressable reporter)
                          throws IOException
```
    Throws:
    
    IOException
  - openHRegion
```
protected HRegion openHRegion(CancelableProgressable reporter)
                       throws IOException
```
    Open HRegion. Calls initialize and sets sequenceId.
    
    Returns:
    
    Returns this
    
    Throws:
    
    IOException
  - openReadOnlyFileSystemHRegion
```
public static HRegion openReadOnlyFileSystemHRegion(org.apache.hadoop.conf.Configuration conf,
                                                    org.apache.hadoop.fs.FileSystem fs,
                                                    org.apache.hadoop.fs.Path tableDir,
                                                    RegionInfo info,
                                                    TableDescriptor htd)
                                             throws IOException
```
    Open a Region on a read-only file-system (like hdfs snapshots)
    
    Parameters:
    
    conf - The Configuration object to use.
    
    fs - Filesystem to use
    
    info - Info for region to be opened.
    
    htd - the table descriptor
    
    Returns:
    
    new HRegion
    
    Throws:
    
    IOException
  - warmupHRegion
```
public static void warmupHRegion(RegionInfo info,
                                 TableDescriptor htd,
                                 WAL wal,
                                 org.apache.hadoop.conf.Configuration conf,
                                 RegionServerServices rsServices,
                                 CancelableProgressable reporter)
                          throws IOException
```
    Throws:
    
    IOException
  - getRegionDir
```
@Deprecated
public static org.apache.hadoop.fs.Path getRegionDir(org.apache.hadoop.fs.Path tabledir,
                                                                 String name)
```
    Deprecated. For tests only; to be removed.
    
    Computes the Path of the HRegion
    
    Parameters:
    
    tabledir - qualified path for table
    
    name - ENCODED region name
    
    Returns:
    
    Path of HRegion directory
  - rowIsInRange
```
public static boolean rowIsInRange(RegionInfo info,
                                   byte[] row)
```
    Determines if the specified row is within the row range specified by the specified RegionInfo
    
    Parameters:
    
    info - RegionInfo that specifies the row range
    
    row - row to be checked
    
    Returns:
    
    true if the row is within the range specified by the RegionInfo
  - rowIsInRange
```
public static boolean rowIsInRange(RegionInfo info,
                                   byte[] row,
                                   int offset,
                                   short length)
```
  - get
```
public Result get(Get get)
           throws IOException
```
    Description copied from interface: Region
    
    Do a get based on the get parameter.
    
    Specified by:
    
    get in interface Region
    
    Parameters:
    
    get - query parameters
    
    Returns:
    
    result of the operation
    
    Throws:
    
    IOException
  - prepareGet
```
void prepareGet(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
  - get
```
public List<Cell> get(Get get,
                      boolean withCoprocessor,
                      long nonceGroup,
                      long nonce)
               throws IOException
```
    Throws:
    
    IOException
  - metricsUpdateForGet
```
void metricsUpdateForGet(List<Cell> results,
                         long before)
```
  - 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,
                                long nonceGroup,
                                long nonce)
                         throws IOException
```
    Perform atomic (all or none) mutations within the region.
    
    Specified by:
    
    mutateRowsWithLocks in interface Region
    
    Parameters:
    
    mutations - The list of mutations to perform. mutations can contain operations for multiple rows. Caller has to ensure that all rows are contained in this region.
    
    rowsToLock - Rows to lock
    
    nonceGroup - Optional nonce group of the operation (client Id)
    
    nonce - Optional nonce of the operation (unique random id to ensure "more idempotence") If multiple rows are locked care should be taken that rowsToLock is sorted in order to avoid deadlocks.
    
    Throws:
    
    IOException
  - getLoadStatistics
```
public org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.RegionLoadStats getLoadStatistics()
```
    Returns:
    
    statistics about the current load of the region
  - processRowsWithLocks
```
public void processRowsWithLocks(RowProcessor<?,?> processor)
                          throws IOException
```
    Description copied from interface: Region
    
    Performs atomic multiple reads and writes on a given row.
    
    Specified by:
    
    processRowsWithLocks in interface Region
    
    Parameters:
    
    processor - The object defines the reads and writes to a row.
    
    Throws:
    
    IOException
  - processRowsWithLocks
```
public void processRowsWithLocks(RowProcessor<?,?> processor,
                                 long nonceGroup,
                                 long nonce)
                          throws IOException
```
    Description copied from interface: Region
    
    Performs atomic multiple reads and writes on a given row.
    
    Specified by:
    
    processRowsWithLocks in interface Region
    
    Parameters:
    
    processor - The object defines the reads and writes to a row.
    
    nonceGroup - Optional nonce group of the operation (client Id)
    
    nonce - Optional nonce of the operation (unique random id to ensure "more idempotence")
    
    Throws:
    
    IOException
  - processRowsWithLocks
```
public void processRowsWithLocks(RowProcessor<?,?> processor,
                                 long timeout,
                                 long nonceGroup,
                                 long nonce)
                          throws IOException
```
    Description copied from interface: Region
    
    Performs atomic multiple reads and writes on a given row.
    
    Specified by:
    
    processRowsWithLocks in interface Region
    
    Parameters:
    
    processor - The object defines the reads and writes to a row.
    
    timeout - The timeout of the processor.process() execution Use a negative number to switch off the time bound
    
    nonceGroup - Optional nonce group of the operation (client Id)
    
    nonce - Optional nonce of the operation (unique random id to ensure "more idempotence")
    
    Throws:
    
    IOException
  - preProcess
```
private void preProcess(RowProcessor<?,?> processor,
                        WALEdit walEdit)
                 throws IOException
```
    Throws:
    
    IOException
  - doProcessRowWithTimeout
```
private void doProcessRowWithTimeout(RowProcessor<?,?> processor,
                                     long now,
                                     HRegion region,
                                     List<Mutation> mutations,
                                     WALEdit walEdit,
                                     long timeout)
                              throws IOException
```
    Throws:
    
    IOException
  - append
```
public Result append(Append append)
              throws IOException
```
    Description copied from interface: Region
    
    Perform one or more append operations on a row.
    
    Specified by:
    
    append in interface Region
    
    Returns:
    
    result of the operation
    
    Throws:
    
    IOException
  - append
```
public Result append(Append mutation,
                     long nonceGroup,
                     long nonce)
              throws IOException
```
    Throws:
    
    IOException
  - increment
```
public Result increment(Increment increment)
                 throws IOException
```
    Description copied from interface: Region
    
    Perform one or more increment operations on a row.
    
    Specified by:
    
    increment in interface Region
    
    Returns:
    
    result of the operation
    
    Throws:
    
    IOException
  - increment
```
public Result increment(Increment mutation,
                        long nonceGroup,
                        long nonce)
                 throws IOException
```
    Throws:
    
    IOException
  - doDelta
```
private Result doDelta(Region.Operation op,
                       Mutation mutation,
                       long nonceGroup,
                       long nonce,
                       boolean returnResults)
                throws IOException
```
    Add "deltas" to Cells. Deltas are increments or appends. Switch on op.
    If increment, add deltas to current values or if an append, then append the deltas to the current Cell values.
    Append and Increment code paths are mostly the same. They differ in just a few places. This method does the code path for increment and append and then in key spots, switches on the passed in op to do increment or append specific paths.
    
    Throws:
    
    IOException
  - doWALAppend
```
private MultiVersionConcurrencyControl.WriteEntry doWALAppend(WALEdit walEdit,
                                                              Durability durability,
                                                              long nonceGroup,
                                                              long nonce)
                                                       throws IOException
```
    Throws:
    
    IOException
  - doWALAppend
```
private MultiVersionConcurrencyControl.WriteEntry doWALAppend(WALEdit walEdit,
                                                              Durability durability,
                                                              List<UUID> clusterIds,
                                                              long now,
                                                              long nonceGroup,
                                                              long nonce)
                                                       throws IOException
```
    Throws:
    
    IOException
  - doWALAppend
```
private MultiVersionConcurrencyControl.WriteEntry doWALAppend(WALEdit walEdit,
                                                              Durability durability,
                                                              List<UUID> clusterIds,
                                                              long now,
                                                              long nonceGroup,
                                                              long nonce,
                                                              long origLogSeqNum)
                                                       throws IOException
```
    Returns:
    
    writeEntry associated with this append
    
    Throws:
    
    IOException
  - doCoprocessorPreCall
```
private Result doCoprocessorPreCall(Region.Operation op,
                                    Mutation mutation)
                             throws IOException
```
    Do coprocessor pre-increment or pre-append call.
    
    Returns:
    
    Result returned out of the coprocessor, which means bypass all further processing and return the proffered Result instead, or null which means proceed.
    
    Throws:
    
    IOException
  - reckonDeltas
```
private WALEdit reckonDeltas(Region.Operation op,
                             Mutation mutation,
                             Durability effectiveDurability,
                             Map<HStore,List<Cell>> forMemStore,
                             List<Cell> results)
                      throws IOException
```
    Reckon the Cells to apply to WAL, memstore, and to return to the Client; these Sets are not always the same dependent on whether to write WAL.
    
    Parameters:
    
    results - Fill in here what goes back to the Client if it is non-null (if null, client doesn't want results).
    
    forMemStore - Fill in here what to apply to the MemStore (by Store).
    
    Returns:
    
    A WALEdit to apply to WAL or null if we are to skip the WAL.
    
    Throws:
    
    IOException
  - reckonDeltasByStore
```
private List<Cell> reckonDeltasByStore(HStore store,
                                       Region.Operation op,
                                       Mutation mutation,
                                       Durability effectiveDurability,
                                       long now,
                                       List<Cell> deltas,
                                       List<Cell> results)
                                throws IOException
```
    Reckon the Cells to apply to WAL, memstore, and to return to the Client in passed column family/Store. Does Get of current value and then adds passed in deltas for this Store returning the result.
    
    Parameters:
    
    op - Whether Increment or Append
    
    mutation - The encompassing Mutation object
    
    deltas - Changes to apply to this Store; either increment amount or data to append
    
    results - In here we accumulate all the Cells we are to return to the client. If null, client doesn't want results returned.
    
    Returns:
    
    Resulting Cells after deltas have been applied to current values. Side effect is our filling out of the results List.
    
    Throws:
    
    IOException
  - reckonDelta
```
private static Cell reckonDelta(Cell delta,
                                Cell currentCell,
                                byte[] columnFamily,
                                long now,
                                Mutation mutation,
                                Function<Cell,byte[]> supplier)
                         throws IOException
```
    Throws:
    
    IOException
  - getLongValue
```
private static long getLongValue(Cell cell)
                          throws DoNotRetryIOException
```
    Returns:
    
    Get the long out of the passed in Cell
    
    Throws:
    
    DoNotRetryIOException
  - get
```
private List<Cell> get(Mutation mutation,
                       HStore store,
                       List<Cell> coordinates,
                       IsolationLevel isolation,
                       TimeRange tr)
                throws IOException
```
    Do a specific Get on passed columnFamily and column qualifiers.
    
    Parameters:
    
    mutation - Mutation we are doing this Get for.
    
    store - Which column family on row (TODO: Go all Gets in one go)
    
    coordinates - Cells from mutation used as coordinates applied to Get.
    
    Returns:
    
    Return list of Cells found.
    
    Throws:
    
    IOException
  - sort
```
private static List<Cell> sort(List<Cell> cells,
                               CellComparator comparator)
```
    Returns:
    
    Sorted list of cells using comparator
  - checkFamily
```
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.
  - registerService
```
public boolean registerService(com.google.protobuf.Service instance)
```
    Registers a new protocol buffer Service subclass as a coprocessor endpoint to be available for handling Region#execService(com.google.protobuf.RpcController, org.apache.hadoop.hbase.protobuf.generated.ClientProtos.CoprocessorServiceCall) calls.
    Only a single instance may be registered per region for a given Service subclass (the instances are keyed on Descriptors.ServiceDescriptor.getFullName(). After the first registration, subsequent calls with the same service name will fail with a return value of false.
    
    Parameters:
    
    instance - the Service subclass instance to expose as a coprocessor endpoint
    
    Returns:
    
    true if the registration was successful, false otherwise
  - execService
```
public com.google.protobuf.Message execService(com.google.protobuf.RpcController controller,
                                               org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.CoprocessorServiceCall call)
                                        throws IOException
```
    Executes a single protocol buffer coprocessor endpoint Service method using the registered protocol handlers. Service implementations must be registered via the registerService(com.google.protobuf.Service) method before they are available.
    
    Parameters:
    
    controller - an RpcContoller implementation to pass to the invoked service
    
    call - a CoprocessorServiceCall instance identifying the service, method, and parameters for the method invocation
    
    Returns:
    
    a protocol buffer Message instance containing the method's result
    
    Throws:
    
    IOException - if no registered service handler is found or an error occurs during the invocation
    
    See Also:
    
    registerService(com.google.protobuf.Service)
  - shouldForceSplit
```
boolean shouldForceSplit()
```
  - getExplicitSplitPoint
```
byte[] getExplicitSplitPoint()
```
  - forceSplit
```
void forceSplit(byte[] sp)
```
  - clearSplit
```
void clearSplit()
```
  - 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()
```
    Returns:
    
    the coprocessor host
  - setCoprocessorHost
```
public void setCoprocessorHost(RegionCoprocessorHost coprocessorHost)
```
    Parameters:
    
    coprocessorHost - the new coprocessor host
  - startRegionOperation
```
public void startRegionOperation()
                          throws IOException
```
    Description copied from interface: Region
    
    This method needs to be called before any public call that reads or modifies data. Acquires a read lock and checks if the region is closing or closed.
    Region.closeRegionOperation() MUST then always be called after the operation has completed, whether it succeeded or failed.
    
    Specified by:
    
    startRegionOperation in interface Region
    
    Throws:
    
    IOException
  - startRegionOperation
```
public void startRegionOperation(Region.Operation op)
                          throws IOException
```
    Description copied from interface: Region
    
    This method needs to be called before any public call that reads or modifies data. Acquires a read lock and checks if the region is closing or closed.
    Region.closeRegionOperation() MUST then always be called after the operation has completed, whether it succeeded or failed.
    
    Specified by:
    
    startRegionOperation in interface Region
    
    Parameters:
    
    op - The operation is about to be taken on the region
    
    Throws:
    
    IOException
  - closeRegionOperation
```
public void closeRegionOperation()
                          throws IOException
```
    Description copied from interface: Region
    
    Closes the region operation lock.
    
    Specified by:
    
    closeRegionOperation in interface Region
    
    Throws:
    
    IOException
  - closeRegionOperation
```
public void closeRegionOperation(Region.Operation operation)
                          throws IOException
```
    Description copied from interface: Region
    
    Closes the region operation lock. This needs to be called in the finally block corresponding to the try block of Region.startRegionOperation(Operation)
    
    Specified by:
    
    closeRegionOperation in interface Region
    
    Throws:
    
    IOException
  - 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 LongAdders 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
  - sync
```
private void sync(long txid,
                  Durability durability)
           throws IOException
```
    Calls sync with the given transaction ID
    
    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
  - getOpenSeqNum
```
public long getOpenSeqNum()
```
    Returns:
    
    the latest sequence number that was read from storage when this region was opened
  - getMaxStoreSeqId
```
public Map<byte[],Long> getMaxStoreSeqId()
```
    Specified by:
    
    getMaxStoreSeqId in interface Region
    
    Returns:
    
    map of column family names to max sequence id that was read from storage when this region was opened
  - getOldestSeqIdOfStore
```
public long getOldestSeqIdOfStore(byte[] familyName)
```
  - getCompactionState
```
public CompactionState getCompactionState()
```
    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)
```
  - reportCompactionRequestFailure
```
public void reportCompactionRequestFailure()
```
  - incrementCompactionsQueuedCount
```
public void incrementCompactionsQueuedCount()
```
  - decrementCompactionsQueuedCount
```
public void decrementCompactionsQueuedCount()
```
  - incrementFlushesQueuedCount
```
public void incrementFlushesQueuedCount()
```
  - getReadPoint
```
public long getReadPoint()
```
  - 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
  - getCellComparator
```
public CellComparator getCellComparator()
```
    Description copied from interface: Region
    
    The comparator to be used with the region
    
    Specified by:
    
    getCellComparator in interface Region
  - getMemStoreFlushSize
```
public long getMemStoreFlushSize()
```
  - throwException
```
void throwException(String title,
                    String regionName)
```
  - requestCompaction
```
public void requestCompaction(String why,
                              int priority,
                              boolean major,
                              CompactionLifeCycleTracker tracker)
                       throws IOException
```
    Description copied from interface: Region
    
    Request compaction on this region.
    
    Specified by:
    
    requestCompaction in interface Region
    
    Throws:
    
    IOException
  - requestCompaction
```
public void requestCompaction(byte[] family,
                              String why,
                              int priority,
                              boolean major,
                              CompactionLifeCycleTracker tracker)
                       throws IOException
```
    Description copied from interface: Region
    
    Request compaction for the given family
    
    Specified by:
    
    requestCompaction in interface Region
    
    Throws:
    
    IOException
  - requestFlushIfNeeded
```
private void requestFlushIfNeeded()
                           throws RegionTooBusyException
```
    Throws:
    
    RegionTooBusyException
  - requestFlush
```
private void requestFlush()
```
  - requestFlush0
```
private void requestFlush0(FlushLifeCycleTracker tracker)
```
  - requestFlush
```
public void requestFlush(FlushLifeCycleTracker tracker)
                  throws IOException
```
    Description copied from interface: Region
    
    Request flush on this region.
    
    Specified by:
    
    requestFlush in interface Region
    
    Throws:
    
    IOException
  - decorateRegionConfiguration
```
static void decorateRegionConfiguration(org.apache.hadoop.conf.Configuration conf)
```
    This method modifies the region's configuration in order to inject replication-related features
    
    Parameters:
    
    conf - region configurations

Class HRegion

Nested Class Summary

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

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

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

Field Detail

LOG

LOAD_CFS_ON_DEMAND_CONFIG_KEY

HBASE_MAX_CELL_SIZE_KEY

DEFAULT_MAX_CELL_SIZE

DEFAULT_DURABILITY

HBASE_REGIONSERVER_MINIBATCH_SIZE

DEFAULT_HBASE_REGIONSERVER_MINIBATCH_SIZE

WAL_HSYNC_CONF_KEY

DEFAULT_WAL_HSYNC

closed

closing

maxFlushedSeqId

lastFlushOpSeqId

lastReplayedOpenRegionSeqId

lastReplayedCompactionSeqId

lockedRows

stores

coprocessorServiceHandlers

memStoreSizing

regionServicesForStores

numMutationsWithoutWAL

dataInMemoryWithoutWAL

checkAndMutateChecksPassed

checkAndMutateChecksFailed

readRequestsCount

filteredReadRequestsCount

writeRequestsCount

blockedRequestsCount

compactionsFinished

compactionsFailed

compactionNumFilesCompacted

compactionNumBytesCompacted

compactionsQueued

flushesQueued

blockCache

mobFileCache

wal

fs

conf

baseConf

rowLockWaitDuration

DEFAULT_ROWLOCK_WAIT_DURATION

regionDir

walFS

isRestoredRegion

busyWaitDuration

DEFAULT_BUSY_WAIT_DURATION

maxBusyWaitMultiplier

maxBusyWaitDuration

maxCellSize

miniBatchSize

DEFAULT_ROW_PROCESSOR_TIMEOUT

rowProcessorExecutor

scannerReadPoints

openSeqNum

isLoadingCfsOnDemandDefault

majorInProgress

minorInProgress

maxSeqIdInStores

prepareFlushResult

configurationManager

timeoutForWriteLock

writestate

memstoreFlushSize

timestampSlop

rowProcessorTimeout

lastStoreFlushTimeMap

rsServices

rsAccounting

flushCheckInterval

flushPerChanges