HRegion (Apache HBase - Server 2.1.3 API)

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

所有已实现的接口:

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.

嵌套类概要

嵌套类
限定符和类型	类和说明
`static interface`	`HRegion.BulkLoadListener` Listener class to enable callers of bulkLoadHFile() to perform any necessary pre/post processing of a given bulkload call
`static interface`	`HRegion.FlushResult`
`static class`	`HRegion.FlushResultImpl` Objects from this class are created when flushing to describe all the different states that that method ends up in.
`static class`	`HRegion.RowLockImpl` Class used to represent a lock on a row.

从接口继承的嵌套类/接口 org.apache.hadoop.hbase.regionserver.Region
Region.Operation, Region.RowLock

字段概要

字段
限定符和类型	字段和说明
`protected org.apache.hadoop.conf.Configuration`	`conf`
`static long`	`DEEP_OVERHEAD`
`static int`	`DEFAULT_CACHE_FLUSH_INTERVAL` Default interval for the memstore flush
`static long`	`DEFAULT_FLUSH_PER_CHANGES`
`static int`	`DEFAULT_HBASE_REGIONSERVER_MINIBATCH_SIZE`
`static int`	`DEFAULT_MAX_CELL_SIZE`
`static boolean`	`DEFAULT_WAL_HSYNC`
`static long`	`FIXED_OVERHEAD`
`static String`	`HBASE_MAX_CELL_SIZE_KEY`
`static String`	`HBASE_REGIONSERVER_MINIBATCH_SIZE`
`protected long`	`lastReplayedCompactionSeqId`
`protected long`	`lastReplayedOpenRegionSeqId` The sequence id of the last replayed open region event from the primary region.
`static String`	`LOAD_CFS_ON_DEMAND_CONFIG_KEY`
`static long`	`MAX_FLUSH_PER_CHANGES` The following MAX_FLUSH_PER_CHANGES is large enough because each KeyValue has 20+ bytes overhead.
`static String`	`MEMSTORE_FLUSH_PER_CHANGES` Conf key to force a flush if there are already enough changes for one region in memstore
`static String`	`MEMSTORE_PERIODIC_FLUSH_INTERVAL` Conf key for the periodic flush interval
`protected Map<byte[],HStore>`	`stores`
`static int`	`SYSTEM_CACHE_FLUSH_INTERVAL` Default interval for System tables memstore flush
`static String`	`WAL_HSYNC_CONF_KEY`

构造器概要

构造器
构造器和说明
`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)` 已过时。 Use other constructors.

方法概要

所有方法静态方法实例方法具体方法已过时的方法
限定符和类型	方法和说明
`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)`
`boolean`	`areWritesEnabled()`
`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(WALSplitter.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)` 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.
`protected void`	`checkReadOnly()`
`protected void`	`checkReadsEnabled()`
`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.
`void`	`checkTimestamps(Map<byte[],List<Cell>> familyMap, long now)` Check the collection of families for valid timestamps
`Map<byte[],List<HStoreFile>>`	`close()` Close down this HRegion.
`Map<byte[],List<HStoreFile>>`	`close(boolean abort)` Close down this HRegion.
`void`	`closeRegionOperation()` Closes the region operation lock.
`void`	`closeRegionOperation(Region.Operation operation)` Closes the region operation lock.
`void`	`compact(boolean majorCompaction)` Synchronously compact all stores in the region.
`boolean`	`compact(CompactionContext compaction, HStore store, ThroughputController throughputController)` Called by compaction thread and after region is opened to compact the HStores if necessary.
`boolean`	`compact(CompactionContext compaction, HStore store, ThroughputController throughputController, User user)`
`void`	`compactStores()` This is a helper function that compact all the stores synchronously.
`static HDFSBlocksDistribution`	`computeHDFSBlocksDistribution(org.apache.hadoop.conf.Configuration conf, TableDescriptor tableDescriptor, RegionInfo regionInfo)` This is a helper function to compute HDFS block distribution on demand
`static HDFSBlocksDistribution`	`computeHDFSBlocksDistribution(org.apache.hadoop.conf.Configuration conf, TableDescriptor tableDescriptor, RegionInfo regionInfo, org.apache.hadoop.fs.Path tablePath)` This is a helper function to compute HDFS block distribution on demand
`static HRegion`	`createHRegion(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.
`void`	`decrementCompactionsQueuedCount()`
`void`	`delete(Delete delete)` Deletes the specified cells/row.
`void`	`deregisterChildren(ConfigurationManager manager)` Needs to be called to deregister the children from the manager.
`protected void`	`doRegionCompactionPrep()` Do preparation for pending compaction.
`MemStoreSize`	`dropMemStoreContents()` Be careful, this method will drop all data in the memstore of this region.
`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.
`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)`
`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.
`org.apache.hadoop.fs.FileSystem`	`getFilesystem()`
`long`	`getFilteredReadRequestsCount()`
`HDFSBlocksDistribution`	`getHDFSBlocksDistribution()`
`org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.RegionLoadStats`	`getLoadStatistics()`
`ConcurrentHashMap<HashedBytes,org.apache.hadoop.hbase.regionserver.HRegion.RowLockContext>`	`getLockedRows()`
`long`	`getMaxFlushedSeqId()`
`Map<byte[],Long>`	`getMaxStoreSeqId()`
`long`	`getMemStoreDataSize()`
`long`	`getMemStoreFlushSize()`
`long`	`getMemStoreHeapSize()`
`long`	`getMemStoreOffHeapSize()`
`MetricsRegion`	`getMetrics()`
`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)`
`long`	`getOpenSeqNum()`
`int`	`getReadLockCount()`
`long`	`getReadPoint()`
`long`	`getReadPoint(IsolationLevel isolationLevel)`
`long`	`getReadRequestsCount()`
`static org.apache.hadoop.fs.Path`	`getRegionDir(org.apache.hadoop.fs.Path rootdir, RegionInfo info)` 已过时。 For tests only; to be removed.
`static org.apache.hadoop.fs.Path`	`getRegionDir(org.apache.hadoop.fs.Path tabledir, String name)` 已过时。 For tests only; to be removed.
`HRegionFileSystem`	`getRegionFileSystem()`
`RegionInfo`	`getRegionInfo()`
`RegionServicesForStores`	`getRegionServicesForStores()`
`NavigableMap<byte[],Integer>`	`getReplicationScope()`
`Region.RowLock`	`getRowLock(byte[] row)` Get an exclusive ( write lock ) lock on a given row.
`Region.RowLock`	`getRowLock(byte[] row, boolean readLock)` Get a row lock for the specified row.
`protected Region.RowLock`	`getRowLockInternal(byte[] row, boolean readLock, Region.RowLock prevRowLock)`
`org.apache.hadoop.hbase.regionserver.HRegion.RegionScannerImpl`	`getScanner(Scan scan)` Return an iterator that scans over the HRegion, returning the indicated columns and rows specified by the `Scan`.
`org.apache.hadoop.hbase.regionserver.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`.
`long`	`getSmallestReadPoint()`
`RegionSplitPolicy`	`getSplitPolicy()`
`HStore`	`getStore(byte[] column)` Return the Store for the given family Use with caution.
`List<String>`	`getStoreFileList(byte[][] columns)`
`protected ThreadPoolExecutor`	`getStoreFileOpenAndCloseThreadPool(String threadNamePrefix)`
`protected ThreadPoolExecutor`	`getStoreOpenAndCloseThreadPool(String threadNamePrefix)`
`List<HStore>`	`getStores()` Return the list of Stores managed by this region Use with caution.
`TableDescriptor`	`getTableDescriptor()`
`WAL`	`getWAL()`
`org.apache.hadoop.fs.Path`	`getWALRegionDir()`
`long`	`getWriteRequestsCount()`
`int`	`hashCode()`
`boolean`	`hasReferences()`
`long`	`heapSize()`
`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()` 已过时。 use HRegion.createHRegion() or HRegion.openHRegion()
`protected HStore`	`instantiateHStore(ColumnFamilyDescriptor family)`
`protected RegionScanner`	`instantiateRegionScanner(Scan scan, List<KeyValueScanner> additionalScanners)`
`protected org.apache.hadoop.hbase.regionserver.HRegion.RegionScannerImpl`	`instantiateRegionScanner(Scan scan, List<KeyValueScanner> additionalScanners, long nonceGroup, long nonce)`
`protected HRegion.FlushResultImpl`	`internalFlushcache(WAL wal, long myseqid, Collection<HStore> storesToFlush, MonitoredTask status, boolean writeFlushWalMarker, FlushLifeCycleTracker tracker)` Flush the memstore.
`protected HRegion.FlushResultImpl`	`internalFlushCacheAndCommit(WAL wal, MonitoredTask status, org.apache.hadoop.hbase.regionserver.HRegion.PrepareFlushResult prepareResult, Collection<HStore> storesToFlush)`
`protected org.apache.hadoop.hbase.regionserver.HRegion.PrepareFlushResult`	`internalPrepareFlushCache(WAL wal, long myseqid, Collection<HStore> storesToFlush, MonitoredTask status, boolean writeFlushWalMarker, FlushLifeCycleTracker tracker)`
`boolean`	`isAvailable()`
`boolean`	`isClosed()`
`boolean`	`isClosing()`
`boolean`	`isLoadingCfsOnDemandDefault()`
`boolean`	`isMergeable()`
`boolean`	`isReadOnly()`
`boolean`	`isSplittable()`
`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.
`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.
`void`	`processRowsWithLocks(RowProcessor<?,?> processor)` Performs atomic multiple reads and writes on a given row.
`void`	`processRowsWithLocks(RowProcessor<?,?> processor, long nonceGroup, long nonce)` Performs atomic multiple reads and writes on a given row.
`void`	`processRowsWithLocks(RowProcessor<?,?> processor, long timeout, long nonceGroup, long nonce)` Performs atomic multiple reads and writes on a given row.
`void`	`put(Put put)` Puts some data in the table.
`boolean`	`refreshStoreFiles()` Check the region's underlying store files, open the files that have not been opened yet, and remove the store file readers for store files no longer available.
`protected boolean`	`refreshStoreFiles(boolean force)`
`void`	`registerChildren(ConfigurationManager manager)` 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.
`protected long`	`replayRecoveredEditsIfAny(Map<byte[],Long> maxSeqIdInStores, CancelableProgressable reporter, MonitoredTask status)` Read the edits put under this region by wal splitting process.
`void`	`reportCompactionRequestEnd(boolean isMajor, int numFiles, long filesSizeCompacted)`
`void`	`reportCompactionRequestFailure()`
`void`	`reportCompactionRequestStart(boolean isMajor)`
`void`	`requestCompaction(byte[] family, String why, int priority, boolean major, CompactionLifeCycleTracker tracker)` Request compaction for the given family
`void`	`requestCompaction(String why, int priority, boolean major, CompactionLifeCycleTracker tracker)` Request compaction on this region.
`void`	`requestFlush(FlushLifeCycleTracker tracker)` Request flush on this region.
`protected void`	`restoreEdit(HStore s, Cell cell, MemStoreSizing memstoreAccounting)` Used by tests
`static boolean`	`rowIsInRange(RegionInfo info, byte[] row)` Determines if the specified row is within the row range specified by the specified RegionInfo
`static boolean`	`rowIsInRange(RegionInfo info, byte[] row, int offset, short length)`
`void`	`setClosing(boolean closing)` Exposed for some very specific unit tests.
`void`	`setCoprocessorHost(RegionCoprocessorHost coprocessorHost)`
`void`	`setReadsEnabled(boolean readsEnabled)`
`void`	`setTimeoutForWriteLock(long timeoutForWriteLock)` The `doClose(boolean, org.apache.hadoop.hbase.monitoring.MonitoredTask)` will block forever if someone tries proving the dead lock via the unit test.
`void`	`startRegionOperation()` This method needs to be called before any public call that reads or modifies data.
`void`	`startRegionOperation(Region.Operation op)` This method needs to be called before any public call that reads or modifies data.
`String`	`toString()`
`void`	`unblockUpdates()`
`void`	`waitForFlushes()` Wait for all current flushes of the region to complete
`boolean`	`waitForFlushes(long timeout)` Wait for all current flushes of the region to complete
`void`	`waitForFlushesAndCompactions()` Wait for all current flushes and compactions of the region to complete
`static void`	`warmupHRegion(RegionInfo info, TableDescriptor htd, WAL wal, org.apache.hadoop.conf.Configuration conf, RegionServerServices rsServices, CancelableProgressable reporter)`
`protected void`	`writeRegionOpenMarker(WAL wal, long openSeqId)`

从类继承的方法 java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

从接口继承的方法 org.apache.hadoop.hbase.regionserver.Region
checkAndMutate, checkAndRowMutate

- 字段详细资料
  - LOAD_CFS_ON_DEMAND_CONFIG_KEY
```
public static final String LOAD_CFS_ON_DEMAND_CONFIG_KEY
```
    另请参阅:
    
    常量字段值
  - HBASE_MAX_CELL_SIZE_KEY
```
public static final String HBASE_MAX_CELL_SIZE_KEY
```
    另请参阅:
    
    常量字段值
  - DEFAULT_MAX_CELL_SIZE
```
public static final int DEFAULT_MAX_CELL_SIZE
```
    另请参阅:
    
    常量字段值
  - HBASE_REGIONSERVER_MINIBATCH_SIZE
```
public static final String HBASE_REGIONSERVER_MINIBATCH_SIZE
```
    另请参阅:
    
    常量字段值
  - DEFAULT_HBASE_REGIONSERVER_MINIBATCH_SIZE
```
public static final int DEFAULT_HBASE_REGIONSERVER_MINIBATCH_SIZE
```
    另请参阅:
    
    常量字段值
  - WAL_HSYNC_CONF_KEY
```
public static final String WAL_HSYNC_CONF_KEY
```
    另请参阅:
    
    常量字段值
  - DEFAULT_WAL_HSYNC
```
public static final boolean DEFAULT_WAL_HSYNC
```
    另请参阅:
    
    常量字段值
  - lastReplayedOpenRegionSeqId
```
protected volatile long lastReplayedOpenRegionSeqId
```
    The sequence id of the last replayed open region event from the primary region. This is used to skip entries before this due to the possibility of replay edits coming out of order from replication.
  - lastReplayedCompactionSeqId
```
protected volatile long lastReplayedCompactionSeqId
```
  - stores
```
protected final Map<byte[],HStore> stores
```
  - conf
```
protected final org.apache.hadoop.conf.Configuration conf
```
  - MEMSTORE_PERIODIC_FLUSH_INTERVAL
```
public static final String MEMSTORE_PERIODIC_FLUSH_INTERVAL
```
    Conf key for the periodic flush interval
    
    另请参阅:
    
    常量字段值
  - DEFAULT_CACHE_FLUSH_INTERVAL
```
public static final int DEFAULT_CACHE_FLUSH_INTERVAL
```
    Default interval for the memstore flush
    
    另请参阅:
    
    常量字段值
  - SYSTEM_CACHE_FLUSH_INTERVAL
```
public static final int SYSTEM_CACHE_FLUSH_INTERVAL
```
    Default interval for System tables memstore flush
    
    另请参阅:
    
    常量字段值
  - 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
    
    另请参阅:
    
    常量字段值
  - DEFAULT_FLUSH_PER_CHANGES
```
public static final long DEFAULT_FLUSH_PER_CHANGES
```
    另请参阅:
    
    常量字段值
  - 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
    
    另请参阅:
    
    常量字段值
  - FIXED_OVERHEAD
```
public static final long FIXED_OVERHEAD
```
  - DEEP_OVERHEAD
```
public static final long DEEP_OVERHEAD
```
- 构造器详细资料
  - 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)
```
    已过时。 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.
    
    参数:
    
    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.
    
    参数:
    
    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
- 方法详细资料
  - getSmallestReadPoint
```
public long getSmallestReadPoint()
```
    返回:
    
    The smallest mvcc readPoint across all the scanners in this region. Writes older than this readPoint, are included in every read operation.
  - initialize
```
@Deprecated
public long initialize()
                            throws IOException
```
    已过时。 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()
    
    返回:
    
    What the next sequence (edit) id should be.
    
    抛出:
    
    IOException - e
  - writeRegionOpenMarker
```
protected void writeRegionOpenMarker(WAL wal,
                                     long openSeqId)
                              throws IOException
```
    抛出:
    
    IOException
  - hasReferences
```
public boolean hasReferences()
```
    返回:
    
    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
    
    参数:
    
    conf - configuration
    
    tableDescriptor - TableDescriptor of the table
    
    regionInfo - encoded name of the region
    
    返回:
    
    The HDFS blocks distribution for the given region.
    
    抛出:
    
    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
    
    参数:
    
    conf - configuration
    
    tableDescriptor - TableDescriptor of the table
    
    regionInfo - encoded name of the region
    
    tablePath - the table directory
    
    返回:
    
    The HDFS blocks distribution for the given region.
    
    抛出:
    
    IOException
  - getRegionInfo
```
public RegionInfo getRegionInfo()
```
    指定者:
    
    getRegionInfo 在接口中 Region
    
    返回:
    
    region information for this region
  - getReadRequestsCount
```
public long getReadRequestsCount()
```
    指定者:
    
    getReadRequestsCount 在接口中 Region
    
    返回:
    
    read requests count for this region
  - getFilteredReadRequestsCount
```
public long getFilteredReadRequestsCount()
```
    指定者:
    
    getFilteredReadRequestsCount 在接口中 Region
    
    返回:
    
    filtered read requests count for this region
  - getWriteRequestsCount
```
public long getWriteRequestsCount()
```
    指定者:
    
    getWriteRequestsCount 在接口中 Region
    
    返回:
    
    write request count for this region
  - getMemStoreDataSize
```
public long getMemStoreDataSize()
```
    指定者:
    
    getMemStoreDataSize 在接口中 Region
    
    返回:
    
    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()
```
    指定者:
    
    getMemStoreHeapSize 在接口中 Region
    
    返回:
    
    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()
```
    指定者:
    
    getMemStoreOffHeapSize 在接口中 Region
    
    返回:
    
    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()
```
    返回:
    
    store services for this region, to access services required by store level needs
  - getNumMutationsWithoutWAL
```
public long getNumMutationsWithoutWAL()
```
    指定者:
    
    getNumMutationsWithoutWAL 在接口中 Region
    
    返回:
    
    the number of mutations processed bypassing the WAL
  - getDataInMemoryWithoutWAL
```
public long getDataInMemoryWithoutWAL()
```
    指定者:
    
    getDataInMemoryWithoutWAL 在接口中 Region
    
    返回:
    
    the size of data processed bypassing the WAL, in bytes
  - getBlockedRequestsCount
```
public long getBlockedRequestsCount()
```
    指定者:
    
    getBlockedRequestsCount 在接口中 Region
    
    返回:
    
    the number of blocked requests
  - getCheckAndMutateChecksPassed
```
public long getCheckAndMutateChecksPassed()
```
    指定者:
    
    getCheckAndMutateChecksPassed 在接口中 Region
    
    返回:
    
    the number of checkAndMutate guards that passed
  - getCheckAndMutateChecksFailed
```
public long getCheckAndMutateChecksFailed()
```
    指定者:
    
    getCheckAndMutateChecksFailed 在接口中 Region
    
    返回:
    
    the number of failed checkAndMutate guards
  - getMetrics
```
public MetricsRegion getMetrics()
```
  - isClosed
```
public boolean isClosed()
```
    指定者:
    
    isClosed 在接口中 Region
    
    返回:
    
    true if region is closed
  - isClosing
```
public boolean isClosing()
```
    指定者:
    
    isClosing 在接口中 Region
    
    返回:
    
    True if closing process has started
  - isReadOnly
```
public boolean isReadOnly()
```
    指定者:
    
    isReadOnly 在接口中 Region
    
    返回:
    
    True if region is read only
  - isAvailable
```
public boolean isAvailable()
```
    指定者:
    
    isAvailable 在接口中 Region
    
    返回:
    
    true if region is available (not closed and not closing)
  - isSplittable
```
public boolean isSplittable()
```
    指定者:
    
    isSplittable 在接口中 Region
    
    返回:
    
    true if region is splittable
  - isMergeable
```
public boolean isMergeable()
```
    指定者:
    
    isMergeable 在接口中 Region
    
    返回:
    
    true if region is mergeable
  - areWritesEnabled
```
public boolean areWritesEnabled()
```
  - getMVCC
```
public MultiVersionConcurrencyControl getMVCC()
```
  - getMaxFlushedSeqId
```
public long getMaxFlushedSeqId()
```
    指定者:
    
    getMaxFlushedSeqId 在接口中 Region
    
    返回:
    
    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)
```
    返回:
    
    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.
    
    返回:
    
    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.
    
    抛出:
    
    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.
    
    参数:
    
    abort - true if server is aborting (only during testing)
    
    返回:
    
    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.
    
    抛出:
    
    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.
    
    参数:
    
    timeoutForWriteLock - the second time to wait for the write lock in doClose(boolean, org.apache.hadoop.hbase.monitoring.MonitoredTask)
  - waitForFlushesAndCompactions
```
public void waitForFlushesAndCompactions()
```
    Wait for all current flushes and compactions of the region to complete
  - waitForFlushes
```
public void waitForFlushes()
```
    Wait for all current flushes of the region to complete
  - waitForFlushes
```
public boolean waitForFlushes(long timeout)
```
    从接口复制的说明: Region
    
    Wait for all current flushes of the region to complete
    
    指定者:
    
    waitForFlushes 在接口中 Region
    
    参数:
    
    timeout - The maximum time to wait in milliseconds.
    
    返回:
    
    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)
```
  - getTableDescriptor
```
public TableDescriptor getTableDescriptor()
```
    指定者:
    
    getTableDescriptor 在接口中 Region
    
    返回:
    
    table descriptor for this region
  - getWAL
```
public WAL getWAL()
```
    返回:
    
    WAL in use for this region
  - getSplitPolicy
```
public RegionSplitPolicy getSplitPolicy()
```
    返回:
    
    split policy for this region.
  - getFilesystem
```
public org.apache.hadoop.fs.FileSystem getFilesystem()
```
    返回:
    
    FileSystem being used by this region
  - getRegionFileSystem
```
public HRegionFileSystem getRegionFileSystem()
```
    返回:
    
    the HRegionFileSystem used by this region
  - getWALRegionDir
```
public org.apache.hadoop.fs.Path getWALRegionDir()
                                          throws IOException
```
    返回:
    
    the Region directory under WALRootDirectory
    
    抛出:
    
    IOException - if there is an error getting WALRootDir
  - getEarliestFlushTimeForAllStores
```
public long getEarliestFlushTimeForAllStores()
```
    指定者:
    
    getEarliestFlushTimeForAllStores 在接口中 Region
    
    返回:
    
    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
```
    从接口复制的说明: Region
    
    This can be used to determine the last time all files of this region were major compacted.
    
    指定者:
    
    getOldestHfileTs 在接口中 Region
    
    参数:
    
    majorCompactionOnly - Only consider HFile that are the result of major compaction
    
    返回:
    
    the timestamp of the oldest HFile for all stores of this region
    
    抛出:
    
    IOException
  - doRegionCompactionPrep
```
protected void doRegionCompactionPrep()
                               throws IOException
```
    Do preparation for pending compaction.
    
    抛出:
    
    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.
    
    参数:
    
    majorCompaction - True to force a major compaction regardless of thresholds
    
    抛出:
    
    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
    
    抛出:
    
    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.
    
    参数:
    
    compaction - Compaction details, obtained by requestCompaction()
    
    throughputController -
    
    返回:
    
    whether the compaction completed
    
    抛出:
    
    IOException
  - compact
```
public boolean compact(CompactionContext compaction,
                       HStore store,
                       ThroughputController throughputController,
                       User user)
                throws IOException
```
    抛出:
    
    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.
    参数:
    
    force - whether we want to force a flush of all stores
    
    返回:
    
    FlushResult indicating whether the flush was successful or not and if the region needs compacting
    
    抛出:
    
    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.
    参数:
    
    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
    
    返回:
    
    whether the flush is success and whether the region needs compacting
    
    抛出:
    
    IOException - general io exceptions
    
    DroppedSnapshotException - Thrown when replay of wal is required because a Snapshot was not properly persisted. The region is put in closing mode, and the caller MUST abort after this.
  - internalFlushcache
```
protected HRegion.FlushResultImpl internalFlushcache(WAL wal,
                                                     long myseqid,
                                                     Collection<HStore> storesToFlush,
                                                     MonitoredTask status,
                                                     boolean writeFlushWalMarker,
                                                     FlushLifeCycleTracker tracker)
                                              throws IOException
```
    Flush the memstore. Flushing the memstore is a little tricky. We have a lot of updates in the memstore, all of which have also been written to the wal. We need to write those updates in the memstore out to disk, while being able to process reads/writes as much as possible during the flush operation.
    This method may block for some time. Every time you call it, we up the regions sequence id even if we don't flush; i.e. the returned region id will be at least one larger than the last edit applied to this region. The returned id does not refer to an actual edit. The returned id can be used for say installing a bulk loaded file just ahead of the last hfile that was the result of this flush, etc.
    
    参数:
    
    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.
    
    返回:
    
    object describing the flush's state
    
    抛出:
    
    IOException - general io exceptions
    
    DroppedSnapshotException - Thrown when replay of WAL is required.
  - internalPrepareFlushCache
```
protected org.apache.hadoop.hbase.regionserver.HRegion.PrepareFlushResult internalPrepareFlushCache(WAL wal,
                                                                                                    long myseqid,
                                                                                                    Collection<HStore> storesToFlush,
                                                                                                    MonitoredTask status,
                                                                                                    boolean writeFlushWalMarker,
                                                                                                    FlushLifeCycleTracker tracker)
                                                                                             throws IOException
```
    抛出:
    
    IOException
  - internalFlushCacheAndCommit
```
protected HRegion.FlushResultImpl internalFlushCacheAndCommit(WAL wal,
                                                              MonitoredTask status,
                                                              org.apache.hadoop.hbase.regionserver.HRegion.PrepareFlushResult prepareResult,
                                                              Collection<HStore> storesToFlush)
                                                       throws IOException
```
    抛出:
    
    IOException
  - getNextSequenceId
```
protected long getNextSequenceId(WAL wal)
                          throws IOException
```
    Method to safely get the next sequence number.
    
    返回:
    
    Next sequence number unassociated with any actual edit.
    
    抛出:
    
    IOException
  - getScanner
```
public org.apache.hadoop.hbase.regionserver.HRegion.RegionScannerImpl getScanner(Scan scan)
                                                                          throws IOException
```
    从接口复制的说明: 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.
    
    指定者:
    
    getScanner 在接口中 Region
    
    参数:
    
    scan - configured Scan
    
    返回:
    
    RegionScanner
    
    抛出:
    
    IOException - read exceptions
  - getScanner
```
public org.apache.hadoop.hbase.regionserver.HRegion.RegionScannerImpl getScanner(Scan scan,
                                                                                 List<KeyValueScanner> additionalScanners)
                                                                          throws IOException
```
    从接口复制的说明: 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.
    
    指定者:
    
    getScanner 在接口中 Region
    
    参数:
    
    scan - configured Scan
    
    additionalScanners - Any additional scanners to be used
    
    返回:
    
    RegionScanner
    
    抛出:
    
    IOException - read exceptions
  - instantiateRegionScanner
```
protected RegionScanner instantiateRegionScanner(Scan scan,
                                                 List<KeyValueScanner> additionalScanners)
                                          throws IOException
```
    抛出:
    
    IOException
  - instantiateRegionScanner
```
protected org.apache.hadoop.hbase.regionserver.HRegion.RegionScannerImpl instantiateRegionScanner(Scan scan,
                                                                                                  List<KeyValueScanner> additionalScanners,
                                                                                                  long nonceGroup,
                                                                                                  long nonce)
                                                                                           throws IOException
```
    抛出:
    
    IOException
  - prepareDelete
```
public void prepareDelete(Delete delete)
                   throws IOException
```
    Prepare a delete for a row mutation processor
    
    参数:
    
    delete - The passed delete is modified by this method. WARNING!
    
    抛出:
    
    IOException
  - delete
```
public void delete(Delete delete)
            throws IOException
```
    从接口复制的说明: Region
    
    Deletes the specified cells/row.
    
    指定者:
    
    delete 在接口中 Region
    
    抛出:
    
    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.
    
    参数:
    
    mutation -
    
    familyMap -
    
    byteNow -
    
    抛出:
    
    IOException
  - put
```
public void put(Put put)
         throws IOException
```
    从接口复制的说明: Region
    
    Puts some data in the table.
    
    指定者:
    
    put 在接口中 Region
    
    抛出:
    
    IOException
  - batchMutate
```
public OperationStatus[] batchMutate(Mutation[] mutations,
                                     long nonceGroup,
                                     long nonce)
                              throws IOException
```
    抛出:
    
    IOException
  - batchMutate
```
public OperationStatus[] batchMutate(Mutation[] mutations,
                                     boolean atomic,
                                     long nonceGroup,
                                     long nonce)
                              throws IOException
```
    抛出:
    
    IOException
  - batchMutate
```
public OperationStatus[] batchMutate(Mutation[] mutations)
                              throws IOException
```
    从接口复制的说明: Region
    
    Perform a batch of mutations.
    Note this supports only Put and Delete mutations and will ignore other types passed.
    
    指定者:
    
    batchMutate 在接口中 Region
    
    参数:
    
    mutations - the list of mutations
    
    返回:
    
    an array of OperationStatus which internally contains the OperationStatusCode and the exceptionMessage if any.
    
    抛出:
    
    IOException
  - batchReplay
```
public OperationStatus[] batchReplay(WALSplitter.MutationReplay[] mutations,
                                     long replaySeqId)
                              throws IOException
```
    抛出:
    
    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
```
    从接口复制的说明: 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.
    
    指定者:
    
    checkAndMutate 在接口中 Region
    
    参数:
    
    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
    
    返回:
    
    true if mutation was applied, false otherwise
    
    抛出:
    
    IOException
  - checkAndRowMutate
```
public boolean checkAndRowMutate(byte[] row,
                                 byte[] family,
                                 byte[] qualifier,
                                 CompareOperator op,
                                 ByteArrayComparable comparator,
                                 TimeRange timeRange,
                                 RowMutations rm)
                          throws IOException
```
    从接口复制的说明: 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.
    
    指定者:
    
    checkAndRowMutate 在接口中 Region
    
    参数:
    
    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
    
    返回:
    
    true if mutations were applied, false otherwise
    
    抛出:
    
    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).
    
    参数:
    
    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.
    
    抛出:
    
    IOException - if there is an external or internal error causing the snapshot to fail
  - checkReadOnly
```
protected void checkReadOnly()
                      throws IOException
```
    抛出:
    
    IOException - Throws exception if region is in read-only mode.
  - checkReadsEnabled
```
protected void checkReadsEnabled()
                          throws IOException
```
    抛出:
    
    IOException
  - setReadsEnabled
```
public void setReadsEnabled(boolean readsEnabled)
```
  - checkFamilies
```
public void checkFamilies(Collection<byte[]> families)
                   throws NoSuchColumnFamilyException
```
    Check the collection of families for validity.
    
    参数:
    
    families -
    
    抛出:
    
    NoSuchColumnFamilyException
  - checkTimestamps
```
public void checkTimestamps(Map<byte[],List<Cell>> familyMap,
                            long now)
                     throws FailedSanityCheckException
```
    Check the collection of families for valid timestamps
    
    参数:
    
    familyMap -
    
    now - current timestamp
    
    抛出:
    
    FailedSanityCheckException
  - 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.
    
    参数:
    
    maxSeqIdInStores - Any edit found in split editlogs needs to be in excess of the maxSeqId for the store to be applied, else its skipped.
    
    返回:
    
    the sequence id of the last edit added to this region out of the recovered edits log or minSeqId if nothing added from editlogs.
    
    抛出:
    
    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.
    
    抛出:
    
    IOException
  - refreshStoreFiles
```
public boolean refreshStoreFiles()
                          throws IOException
```
    从接口复制的说明: 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.
    
    指定者:
    
    refreshStoreFiles 在接口中 Region
    
    抛出:
    
    IOException
  - refreshStoreFiles
```
protected boolean refreshStoreFiles(boolean force)
                             throws IOException
```
    抛出:
    
    IOException
  - restoreEdit
```
protected void restoreEdit(HStore s,
                           Cell cell,
                           MemStoreSizing memstoreAccounting)
```
    Used by tests
    
    参数:
    
    s - Store to add edit too.
    
    cell - Cell to add.
  - instantiateHStore
```
protected HStore instantiateHStore(ColumnFamilyDescriptor family)
                            throws IOException
```
    抛出:
    
    IOException
  - getStore
```
public HStore getStore(byte[] column)
```
    从接口复制的说明: Region
    
    Return the Store for the given family
    Use with caution. Exposed for use of fixup utilities.
    
    指定者:
    
    getStore 在接口中 Region
    
    返回:
    
    the Store for the given family
  - getStores
```
public List<HStore> getStores()
```
    从接口复制的说明: Region
    
    Return the list of Stores managed by this region
    Use with caution. Exposed for use of fixup utilities.
    
    指定者:
    
    getStores 在接口中 Region
    
    返回:
    
    a list of the Stores managed by this region
  - getStoreFileList
```
public List<String> getStoreFileList(byte[][] columns)
                              throws IllegalArgumentException
```
    指定者:
    
    getStoreFileList 在接口中 Region
    
    返回:
    
    list of store file names for the given families
    
    抛出:
    
    IllegalArgumentException
  - getRowLock
```
public Region.RowLock getRowLock(byte[] row)
                          throws IOException
```
    Get an exclusive ( write lock ) lock on a given row.
    
    参数:
    
    row - Which row to lock.
    
    返回:
    
    A locked RowLock. The lock is exclusive and already aqquired.
    
    抛出:
    
    IOException
  - getRowLock
```
public Region.RowLock getRowLock(byte[] row,
                                 boolean readLock)
                          throws IOException
```
    从接口复制的说明: 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.
    
    指定者:
    
    getRowLock 在接口中 Region
    
    参数:
    
    row - The row actions will be performed against
    
    readLock - is the lock reader or writer. True indicates that a non-exclusive lock is requested
    
    抛出:
    
    IOException
    
    另请参阅:
    
    Region.startRegionOperation(), Region.startRegionOperation(Operation)
  - getRowLockInternal
```
protected Region.RowLock getRowLockInternal(byte[] row,
                                            boolean readLock,
                                            Region.RowLock prevRowLock)
                                     throws IOException
```
    抛出:
    
    IOException
  - getReadLockCount
```
public int getReadLockCount()
```
  - getLockedRows
```
public ConcurrentHashMap<HashedBytes,org.apache.hadoop.hbase.regionserver.HRegion.RowLockContext> getLockedRows()
```
  - bulkLoadHFiles
```
public Map<byte[],List<org.apache.hadoop.fs.Path>> bulkLoadHFiles(Collection<Pair<byte[],String>> familyPaths,
                                                                  boolean assignSeqId,
                                                                  HRegion.BulkLoadListener bulkLoadListener)
                                                           throws IOException
```
    Attempts to atomically load a group of hfiles. This is critical for loading rows with multiple column families atomically.
    
    参数:
    
    familyPaths - List of Pair<byte[] column family, String hfilePath>
    
    bulkLoadListener - Internal hooks enabling massaging/preparation of a file about to be bulk loaded
    
    assignSeqId -
    
    返回:
    
    Map from family to List of store file paths if successful, null if failed recoverably
    
    抛出:
    
    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)
                                                           throws IOException
```
    Attempts to atomically load a group of hfiles. This is critical for loading rows with multiple column families atomically.
    
    参数:
    
    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
    
    返回:
    
    Map from family to List of store file paths if successful, null if failed recoverably
    
    抛出:
    
    IOException - if failed unrecoverably.
  - equals
```
public boolean equals(Object o)
```
    覆盖:
    
    equals 在类中 Object
  - hashCode
```
public int hashCode()
```
    覆盖:
    
    hashCode 在类中 Object
  - toString
```
public String toString()
```
    覆盖:
    
    toString 在类中 Object
  - 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.
    
    参数:
    
    info - Info for region to create.
    
    rootDir - Root directory for HBase instance
    
    wal - shared WAL
    
    initialize - - true to initialize the region
    
    返回:
    
    new HRegion
    
    抛出:
    
    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
```
    抛出:
    
    IOException
  - openHRegion
```
public static HRegion openHRegion(RegionInfo info,
                                  TableDescriptor htd,
                                  WAL wal,
                                  org.apache.hadoop.conf.Configuration conf)
                           throws IOException
```
    Open a Region.
    
    参数:
    
    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.
    
    返回:
    
    new HRegion
    
    抛出:
    
    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.
    
    参数:
    
    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.
    
    返回:
    
    new HRegion
    
    抛出:
    
    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.
    
    参数:
    
    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.
    
    返回:
    
    new HRegion
    
    抛出:
    
    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.
    
    参数:
    
    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.
    
    返回:
    
    new HRegion
    
    抛出:
    
    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.
    
    参数:
    
    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.
    
    返回:
    
    new HRegion
    
    抛出:
    
    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.
    
    参数:
    
    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.
    
    返回:
    
    new HRegion
    
    抛出:
    
    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.
    
    参数:
    
    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.
    
    返回:
    
    new HRegion
    
    抛出:
    
    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)
    
    参数:
    
    other - original object
    
    reporter - An interface we can report progress against.
    
    返回:
    
    new HRegion
    
    抛出:
    
    IOException
  - openHRegion
```
public static Region openHRegion(Region other,
                                 CancelableProgressable reporter)
                          throws IOException
```
    抛出:
    
    IOException
  - openHRegion
```
protected HRegion openHRegion(CancelableProgressable reporter)
                       throws IOException
```
    Open HRegion. Calls initialize and sets sequenceId.
    
    返回:
    
    Returns this
    
    抛出:
    
    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)
    
    参数:
    
    conf - The Configuration object to use.
    
    fs - Filesystem to use
    
    info - Info for region to be opened.
    
    htd - the table descriptor
    
    返回:
    
    new HRegion
    
    抛出:
    
    IOException
  - warmupHRegion
```
public static void warmupHRegion(RegionInfo info,
                                 TableDescriptor htd,
                                 WAL wal,
                                 org.apache.hadoop.conf.Configuration conf,
                                 RegionServerServices rsServices,
                                 CancelableProgressable reporter)
                          throws IOException
```
    抛出:
    
    IOException
  - getRegionDir
```
@Deprecated
public static org.apache.hadoop.fs.Path getRegionDir(org.apache.hadoop.fs.Path tabledir,
                                                                 String name)
```
    已过时。 For tests only; to be removed.
    
    Computes the Path of the HRegion
    
    参数:
    
    tabledir - qualified path for table
    
    name - ENCODED region name
    
    返回:
    
    Path of HRegion directory
  - getRegionDir
```
@Deprecated
public static org.apache.hadoop.fs.Path getRegionDir(org.apache.hadoop.fs.Path rootdir,
                                                                 RegionInfo info)
```
    已过时。 For tests only; to be removed.
    
    Computes the Path of the HRegion
    
    参数:
    
    rootdir - qualified path of HBase root directory
    
    info - RegionInfo for the region
    
    返回:
    
    qualified path of region 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
    
    参数:
    
    info - RegionInfo that specifies the row range
    
    row - row to be checked
    
    返回:
    
    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
```
    从接口复制的说明: Region
    
    Do a get based on the get parameter.
    
    指定者:
    
    get 在接口中 Region
    
    参数:
    
    get - query parameters
    
    返回:
    
    result of the operation
    
    抛出:
    
    IOException
  - get
```
public List<Cell> get(Get get,
                      boolean withCoprocessor)
               throws IOException
```
    从接口复制的说明: Region
    
    Do a get based on the get parameter.
    
    指定者:
    
    get 在接口中 Region
    
    参数:
    
    get - query parameters
    
    withCoprocessor - invoke coprocessor or not. We don't want to always invoke cp.
    
    返回:
    
    list of cells resulting from the operation
    
    抛出:
    
    IOException
  - get
```
public List<Cell> get(Get get,
                      boolean withCoprocessor,
                      long nonceGroup,
                      long nonce)
               throws IOException
```
    抛出:
    
    IOException
  - mutateRow
```
public void mutateRow(RowMutations rm)
               throws IOException
```
    从接口复制的说明: Region
    
    Performs multiple mutations atomically on a single row. Currently Put and Delete are supported.
    
    指定者:
    
    mutateRow 在接口中 Region
    
    参数:
    
    rm - object that specifies the set of mutations to perform atomically
    
    抛出:
    
    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.
    
    指定者:
    
    mutateRowsWithLocks 在接口中 Region
    
    参数:
    
    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.
    
    抛出:
    
    IOException
  - getLoadStatistics
```
public org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.RegionLoadStats getLoadStatistics()
```
    返回:
    
    statistics about the current load of the region
  - processRowsWithLocks
```
public void processRowsWithLocks(RowProcessor<?,?> processor)
                          throws IOException
```
    从接口复制的说明: Region
    
    Performs atomic multiple reads and writes on a given row.
    
    指定者:
    
    processRowsWithLocks 在接口中 Region
    
    参数:
    
    processor - The object defines the reads and writes to a row.
    
    抛出:
    
    IOException
  - processRowsWithLocks
```
public void processRowsWithLocks(RowProcessor<?,?> processor,
                                 long nonceGroup,
                                 long nonce)
                          throws IOException
```
    从接口复制的说明: Region
    
    Performs atomic multiple reads and writes on a given row.
    
    指定者:
    
    processRowsWithLocks 在接口中 Region
    
    参数:
    
    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")
    
    抛出:
    
    IOException
  - processRowsWithLocks
```
public void processRowsWithLocks(RowProcessor<?,?> processor,
                                 long timeout,
                                 long nonceGroup,
                                 long nonce)
                          throws IOException
```
    从接口复制的说明: Region
    
    Performs atomic multiple reads and writes on a given row.
    
    指定者:
    
    processRowsWithLocks 在接口中 Region
    
    参数:
    
    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")
    
    抛出:
    
    IOException
  - append
```
public Result append(Append append)
              throws IOException
```
    从接口复制的说明: Region
    
    Perform one or more append operations on a row.
    
    指定者:
    
    append 在接口中 Region
    
    返回:
    
    result of the operation
    
    抛出:
    
    IOException
  - append
```
public Result append(Append mutation,
                     long nonceGroup,
                     long nonce)
              throws IOException
```
    抛出:
    
    IOException
  - increment
```
public Result increment(Increment increment)
                 throws IOException
```
    从接口复制的说明: Region
    
    Perform one or more increment operations on a row.
    
    指定者:
    
    increment 在接口中 Region
    
    返回:
    
    result of the operation
    
    抛出:
    
    IOException
  - increment
```
public Result increment(Increment mutation,
                        long nonceGroup,
                        long nonce)
                 throws IOException
```
    抛出:
    
    IOException
  - heapSize
```
public long heapSize()
```
    指定者:
    
    heapSize 在接口中 HeapSize
  - registerService
```
public boolean registerService(com.google.protobuf.Service instance)
```
    Registers a new protocol buffer Service subclass as a coprocessor endpoint to be available for handling Region#execService(com.google.protobuf.RpcController, org.apache.hadoop.hbase.protobuf.generated.ClientProtos.CoprocessorServiceCall) calls.
    Only a single instance may be registered per region for a given Service subclass (the instances are keyed on Descriptors.ServiceDescriptor.getFullName(). After the first registration, subsequent calls with the same service name will fail with a return value of false.
    
    参数:
    
    instance - the Service subclass instance to expose as a coprocessor endpoint
    
    返回:
    
    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.
    
    参数:
    
    controller - an RpcContoller implementation to pass to the invoked service
    
    call - a CoprocessorServiceCall instance identifying the service, method, and parameters for the method invocation
    
    返回:
    
    a protocol buffer Message instance containing the method's result
    
    抛出:
    
    IOException - if no registered service handler is found or an error occurs during the invocation
    
    另请参阅:
    
    registerService(com.google.protobuf.Service)
  - 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()
```
    返回:
    
    The priority that this region should have in the compaction queue
  - getCoprocessorHost
```
public RegionCoprocessorHost getCoprocessorHost()
```
    返回:
    
    the coprocessor host
  - setCoprocessorHost
```
public void setCoprocessorHost(RegionCoprocessorHost coprocessorHost)
```
    参数:
    
    coprocessorHost - the new coprocessor host
  - startRegionOperation
```
public void startRegionOperation()
                          throws IOException
```
    从接口复制的说明: 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.
    
    指定者:
    
    startRegionOperation 在接口中 Region
    
    抛出:
    
    IOException
  - startRegionOperation
```
public void startRegionOperation(Region.Operation op)
                          throws IOException
```
    从接口复制的说明: 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.
    
    指定者:
    
    startRegionOperation 在接口中 Region
    
    参数:
    
    op - The operation is about to be taken on the region
    
    抛出:
    
    IOException
  - closeRegionOperation
```
public void closeRegionOperation()
                          throws IOException
```
    从接口复制的说明: Region
    
    Closes the region operation lock.
    
    指定者:
    
    closeRegionOperation 在接口中 Region
    
    抛出:
    
    IOException
  - closeRegionOperation
```
public void closeRegionOperation(Region.Operation operation)
                          throws IOException
```
    从接口复制的说明: Region
    
    Closes the region operation lock. This needs to be called in the finally block corresponding to the try block of Region.startRegionOperation(Operation)
    
    指定者:
    
    closeRegionOperation 在接口中 Region
    
    抛出:
    
    IOException
  - getOpenSeqNum
```
public long getOpenSeqNum()
```
    返回:
    
    the latest sequence number that was read from storage when this region was opened
  - getMaxStoreSeqId
```
public Map<byte[],Long> getMaxStoreSeqId()
```
    指定者:
    
    getMaxStoreSeqId 在接口中 Region
    
    返回:
    
    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()
```
    指定者:
    
    getCompactionState 在接口中 Region
    
    返回:
    
    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.
    
    指定者:
    
    onConfigurationChange 在接口中 ConfigurationObserver
  - registerChildren
```
public void registerChildren(ConfigurationManager manager)
```
    Needs to be called to register the children to the manager.
    
    指定者:
    
    registerChildren 在接口中 PropagatingConfigurationObserver
    
    参数:
    
    manager - : to register to
  - deregisterChildren
```
public void deregisterChildren(ConfigurationManager manager)
```
    Needs to be called to deregister the children from the manager.
    
    指定者:
    
    deregisterChildren 在接口中 PropagatingConfigurationObserver
    
    参数:
    
    manager - : to deregister from
  - getCellComparator
```
public CellComparator getCellComparator()
```
    从接口复制的说明: Region
    
    The comparator to be used with the region
    
    指定者:
    
    getCellComparator 在接口中 Region
  - getMemStoreFlushSize
```
public long getMemStoreFlushSize()
```
  - requestCompaction
```
public void requestCompaction(String why,
                              int priority,
                              boolean major,
                              CompactionLifeCycleTracker tracker)
                       throws IOException
```
    从接口复制的说明: Region
    
    Request compaction on this region.
    
    指定者:
    
    requestCompaction 在接口中 Region
    
    抛出:
    
    IOException
  - requestCompaction
```
public void requestCompaction(byte[] family,
                              String why,
                              int priority,
                              boolean major,
                              CompactionLifeCycleTracker tracker)
                       throws IOException
```
    从接口复制的说明: Region
    
    Request compaction for the given family
    
    指定者:
    
    requestCompaction 在接口中 Region
    
    抛出:
    
    IOException
  - requestFlush
```
public void requestFlush(FlushLifeCycleTracker tracker)
                  throws IOException
```
    从接口复制的说明: Region
    
    Request flush on this region.
    
    指定者:
    
    requestFlush 在接口中 Region
    
    抛出:
    
    IOException

类 HRegion

嵌套类概要

从接口继承的嵌套类/接口 org.apache.hadoop.hbase.regionserver.Region

字段概要

构造器概要

方法概要

从类继承的方法 java.lang.Object

从接口继承的方法 org.apache.hadoop.hbase.regionserver.Region

字段详细资料

LOAD_CFS_ON_DEMAND_CONFIG_KEY

HBASE_MAX_CELL_SIZE_KEY

DEFAULT_MAX_CELL_SIZE

HBASE_REGIONSERVER_MINIBATCH_SIZE

DEFAULT_HBASE_REGIONSERVER_MINIBATCH_SIZE

WAL_HSYNC_CONF_KEY

DEFAULT_WAL_HSYNC

lastReplayedOpenRegionSeqId

lastReplayedCompactionSeqId

stores

conf

MEMSTORE_PERIODIC_FLUSH_INTERVAL

DEFAULT_CACHE_FLUSH_INTERVAL

SYSTEM_CACHE_FLUSH_INTERVAL

MEMSTORE_FLUSH_PER_CHANGES

DEFAULT_FLUSH_PER_CHANGES

MAX_FLUSH_PER_CHANGES

FIXED_OVERHEAD

DEEP_OVERHEAD

构造器详细资料

HRegion

HRegion

方法详细资料

getSmallestReadPoint

initialize

writeRegionOpenMarker

hasReferences

blockUpdates

unblockUpdates

getHDFSBlocksDistribution

computeHDFSBlocksDistribution

computeHDFSBlocksDistribution

getRegionInfo

getReadRequestsCount

getFilteredReadRequestsCount

getWriteRequestsCount

getMemStoreDataSize

getMemStoreHeapSize

getMemStoreOffHeapSize

getRegionServicesForStores

getNumMutationsWithoutWAL

getDataInMemoryWithoutWAL

getBlockedRequestsCount

getCheckAndMutateChecksPassed

getCheckAndMutateChecksFailed

getMetrics

isClosed

isClosing

isReadOnly

isAvailable

isSplittable

isMergeable

areWritesEnabled

getMVCC

getMaxFlushedSeqId

getReadPoint

isLoadingCfsOnDemandDefault

close

close

setClosing

setTimeoutForWriteLock

waitForFlushesAndCompactions

waitForFlushes

waitForFlushes

getStoreOpenAndCloseThreadPool

getStoreFileOpenAndCloseThreadPool

getTableDescriptor

getWAL

getSplitPolicy

getFilesystem

getRegionFileSystem