RegionInfo (Apache HBase 2.4.0 API)

All Superinterfaces:

Comparable<RegionInfo>

All Known Implementing Classes:

HRegionInfo
```
@InterfaceAudience.Public
public interface RegionInfo
extends Comparable<RegionInfo>
```
Information about a region. A region is a range of keys in the whole keyspace of a table, an identifier (a timestamp) for differentiating between subset ranges (after region split) and a replicaId for differentiating the instance for the same range and some status information about the region. The region has a unique name which consists of the following fields:
- tableName : The name of the table
- startKey : The startKey for the region.
- regionId : A timestamp when the region is created.
- replicaId : An id starting from 0 to differentiate replicas of the same region range but hosted in separated servers. The same region range can be hosted in multiple locations.
- encodedName : An MD5 encoded string for the region name.
Other than the fields in the region name, region info contains:
- endKey : the endKey for the region (exclusive)
- split : Whether the region is split
- offline : Whether the region is offline

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods Deprecated Methods
Modifier and Type	Method and Description
`static boolean`	`areAdjacent(RegionInfo regionA, RegionInfo regionB)` Check whether two regions are adjacent; i.e.
`default int`	`compareTo(RegionInfo other)`
`boolean`	`containsRange(byte[] rangeStartKey, byte[] rangeEndKey)`
`boolean`	`containsRow(byte[] row)`
`static RegionInfo`	`createMobRegionInfo(TableName tableName)` Creates a RegionInfo object for MOB data.
`static byte[]`	`createRegionName(TableName tableName, byte[] startKey, byte[] id, boolean newFormat)` Make a region name of passed parameters.
`static byte[]`	`createRegionName(TableName tableName, byte[] startKey, byte[] id, int replicaId, boolean newFormat)` Make a region name of passed parameters.
`static byte[]`	`createRegionName(TableName tableName, byte[] startKey, long regionid, boolean newFormat)` Make a region name of passed parameters.
`static byte[]`	`createRegionName(TableName tableName, byte[] startKey, long regionid, int replicaId, boolean newFormat)` Make a region name of passed parameters.
`static byte[]`	`createRegionName(TableName tableName, byte[] startKey, String id, boolean newFormat)` Make a region name of passed parameters.
`String`	`getEncodedName()`
`byte[]`	`getEncodedNameAsBytes()`
`byte[]`	`getEndKey()`
`long`	`getRegionId()`
`byte[]`	`getRegionName()`
`String`	`getRegionNameAsString()`
`int`	`getReplicaId()`
`String`	`getShortNameToLog()`
`static String`	`getShortNameToLog(List<RegionInfo> ris)`
`static String`	`getShortNameToLog(RegionInfo... hris)`
`byte[]`	`getStartKey()`
`static byte[]`	`getStartKey(byte[] regionName)` Gets the start key from the specified region name.
`TableName`	`getTable()`
`default boolean`	`isAdjacent(RegionInfo other)`
`default boolean`	`isDegenerate()`
`default boolean`	`isFirst()`
`default boolean`	`isLast()`
`boolean`	`isMetaRegion()`
`default boolean`	`isNext(RegionInfo after)`
`boolean`	`isOffline()` Deprecated. since 3.0.0 and will be removed in 4.0.0
`default boolean`	`isOverlap(RegionInfo other)`
`boolean`	`isSplit()`
`boolean`	`isSplitParent()` Deprecated. since 3.0.0 and will be removed in 4.0.0, Use `isSplit()` instead.
`static List<RegionInfo>`	`parseDelimitedFrom(byte[] bytes, int offset, int length)` Parses all the RegionInfo instances from the passed in stream until EOF.
`static RegionInfo`	`parseFrom(DataInputStream in)` Parses an RegionInfo instance from the passed in stream.
`static byte[][]`	`parseRegionName(byte[] regionName)` Separate elements of a regionName.
`static byte[][]`	`parseRegionNameOrReturnNull(byte[] regionName)` Separate elements of a regionName.
`static String`	`prettyPrint(String encodedRegionName)` Use logging.
`static byte[]`	`toByteArray(RegionInfo ri)`
`static byte[]`	`toDelimitedByteArray(RegionInfo... infos)` Serializes given RegionInfo's as a byte array.
`static byte[]`	`toDelimitedByteArray(RegionInfo ri)` Use this instead of `toByteArray(RegionInfo)` when writing to a stream and you want to use the pb mergeDelimitedFrom (w/o the delimiter, pb reads to EOF which may not be what you want).

- Method Detail
  - getShortNameToLog
```
String getShortNameToLog()
```
    Returns:
    
    Return a short, printable name for this region (usually encoded name) for us logging.
  - getRegionId
```
long getRegionId()
```
    Returns:
    
    the regionId.
  - getRegionName
```
byte[] getRegionName()
```
    Returns:
    
    the regionName as an array of bytes.
    
    See Also:
    
    getRegionNameAsString()
  - getRegionNameAsString
```
String getRegionNameAsString()
```
    Returns:
    
    Region name as a String for use in logging, etc.
  - getEncodedName
```
String getEncodedName()
```
    Returns:
    
    the encoded region name.
  - getEncodedNameAsBytes
```
byte[] getEncodedNameAsBytes()
```
    Returns:
    
    the encoded region name as an array of bytes.
  - getStartKey
```
byte[] getStartKey()
```
    Returns:
    
    the startKey.
  - getEndKey
```
byte[] getEndKey()
```
    Returns:
    
    the endKey.
  - getTable
```
TableName getTable()
```
    Returns:
    
    current table name of the region
  - getReplicaId
```
int getReplicaId()
```
    Returns:
    
    returns region replica id
  - isSplit
```
boolean isSplit()
```
    Returns:
    
    True if has been split and has daughters.
  - isOffline
```
@Deprecated
boolean isOffline()
```
    Deprecated. since 3.0.0 and will be removed in 4.0.0
    
    Returns:
    
    True if this region is offline.
    
    See Also:
    
    HBASE-25210
  - isSplitParent
```
@Deprecated
boolean isSplitParent()
```
    Deprecated. since 3.0.0 and will be removed in 4.0.0, Use isSplit() instead.
    
    Returns:
    
    True if this is a split parent region.
    
    See Also:
    
    HBASE-25210
  - isMetaRegion
```
boolean isMetaRegion()
```
    Returns:
    
    true if this region is a meta region.
  - containsRange
```
boolean containsRange(byte[] rangeStartKey,
                      byte[] rangeEndKey)
```
    Returns:
    
    true if the given inclusive range of rows is fully contained by this region. For example, if the region is foo,a,g and this is passed ["b","c"] or ["a","c"] it will return true, but if this is passed ["b","z"] it will return false.
    
    Throws:
    
    IllegalArgumentException - if the range passed is invalid (ie. end < start)
  - containsRow
```
boolean containsRow(byte[] row)
```
    Returns:
    
    true if the given row falls in this region.
  - getShortNameToLog
```
static String getShortNameToLog(RegionInfo... hris)
```
    Returns:
    
    Return a String of short, printable names for hris (usually encoded name) for us logging.
  - getShortNameToLog
```
static String getShortNameToLog(List<RegionInfo> ris)
```
    Returns:
    
    Return a String of short, printable names for hris (usually encoded name) for us logging.
  - getStartKey
```
static byte[] getStartKey(byte[] regionName)
                   throws IOException
```
    Gets the start key from the specified region name.
    
    Returns:
    
    Start key.
    
    Throws:
    
    IOException
  - areAdjacent
```
static boolean areAdjacent(RegionInfo regionA,
                           RegionInfo regionB)
```
    Check whether two regions are adjacent; i.e. lies just before or just after in a table.
    
    Returns:
    
    true if two regions are adjacent
  - toByteArray
```
static byte[] toByteArray(RegionInfo ri)
```
    Returns:
    
    This instance serialized as protobuf w/ a magic pb prefix.
    
    See Also:
    
    parseFrom(byte[])
  - prettyPrint
```
static String prettyPrint(String encodedRegionName)
```
    Use logging.
    
    Parameters:
    
    encodedRegionName - The encoded regionname.
    
    Returns:
    
    hbase:meta if passed 1028785192 else returns encodedRegionName
  - createRegionName
```
static byte[] createRegionName(TableName tableName,
                               byte[] startKey,
                               long regionid,
                               boolean newFormat)
```
    Make a region name of passed parameters.
    
    Parameters:
    
    startKey - Can be null
    
    regionid - Region id (Usually timestamp from when region was created).
    
    newFormat - should we create the region name in the new format (such that it contains its encoded name?).
    
    Returns:
    
    Region name made of passed tableName, startKey and id
  - createRegionName
```
static byte[] createRegionName(TableName tableName,
                               byte[] startKey,
                               String id,
                               boolean newFormat)
```
    Make a region name of passed parameters.
    
    Parameters:
    
    startKey - Can be null
    
    id - Region id (Usually timestamp from when region was created).
    
    newFormat - should we create the region name in the new format (such that it contains its encoded name?).
    
    Returns:
    
    Region name made of passed tableName, startKey and id
  - createRegionName
```
static byte[] createRegionName(TableName tableName,
                               byte[] startKey,
                               long regionid,
                               int replicaId,
                               boolean newFormat)
```
    Make a region name of passed parameters.
    
    Parameters:
    
    startKey - Can be null
    
    regionid - Region id (Usually timestamp from when region was created).
    
    newFormat - should we create the region name in the new format (such that it contains its encoded name?).
    
    Returns:
    
    Region name made of passed tableName, startKey, id and replicaId
  - createRegionName
```
static byte[] createRegionName(TableName tableName,
                               byte[] startKey,
                               byte[] id,
                               boolean newFormat)
```
    Make a region name of passed parameters.
    
    Parameters:
    
    startKey - Can be null
    
    id - Region id (Usually timestamp from when region was created).
    
    newFormat - should we create the region name in the new format (such that it contains its encoded name?).
    
    Returns:
    
    Region name made of passed tableName, startKey and id
  - createRegionName
```
static byte[] createRegionName(TableName tableName,
                               byte[] startKey,
                               byte[] id,
                               int replicaId,
                               boolean newFormat)
```
    Make a region name of passed parameters.
    
    Parameters:
    
    startKey - Can be null
    
    id - Region id (Usually timestamp from when region was created).
    
    newFormat - should we create the region name in the new format
    
    Returns:
    
    Region name made of passed tableName, startKey, id and replicaId
  - createMobRegionInfo
```
static RegionInfo createMobRegionInfo(TableName tableName)
```
    Creates a RegionInfo object for MOB data.
    
    Parameters:
    
    tableName - the name of the table
    
    Returns:
    
    the MOB RegionInfo.
  - parseRegionName
```
static byte[][] parseRegionName(byte[] regionName)
                         throws IOException
```
    Separate elements of a regionName.
    
    Returns:
    
    Array of byte[] containing tableName, startKey and id OR null if not parseable as a region name.
    
    Throws:
    
    IOException - if not parseable as regionName.
  - parseRegionNameOrReturnNull
```
static byte[][] parseRegionNameOrReturnNull(byte[] regionName)
```
    Separate elements of a regionName. Region name is of the format: tablename,startkey,regionIdTimestamp[_replicaId][.encodedName.]. Startkey can contain the delimiter (',') so we parse from the start and then parse from the end.
    
    Returns:
    
    Array of byte[] containing tableName, startKey and id OR null if not parseable as a region name.
  - toDelimitedByteArray
```
static byte[] toDelimitedByteArray(RegionInfo... infos)
                            throws IOException
```
    Serializes given RegionInfo's as a byte array. Use this instead of toByteArray(RegionInfo) when writing to a stream and you want to use the pb mergeDelimitedFrom (w/o the delimiter, pb reads to EOF which may not be what you want). parseDelimitedFrom(byte[], int, int) can be used to read back the instances.
    
    Parameters:
    
    infos - RegionInfo objects to serialize
    
    Returns:
    
    This instance serialized as a delimited protobuf w/ a magic pb prefix.
    
    Throws:
    
    IOException
  - toDelimitedByteArray
```
static byte[] toDelimitedByteArray(RegionInfo ri)
                            throws IOException
```
    Use this instead of toByteArray(RegionInfo) when writing to a stream and you want to use the pb mergeDelimitedFrom (w/o the delimiter, pb reads to EOF which may not be what you want).
    
    Returns:
    
    This instance serialized as a delimied protobuf w/ a magic pb prefix.
    
    Throws:
    
    IOException
  - parseFrom
```
static RegionInfo parseFrom(DataInputStream in)
                     throws IOException
```
    Parses an RegionInfo instance from the passed in stream. Presumes the RegionInfo was serialized to the stream with toDelimitedByteArray(RegionInfo).
    
    Returns:
    
    An instance of RegionInfo.
    
    Throws:
    
    IOException
  - parseDelimitedFrom
```
static List<RegionInfo> parseDelimitedFrom(byte[] bytes,
                                           int offset,
                                           int length)
                                    throws IOException
```
    Parses all the RegionInfo instances from the passed in stream until EOF. Presumes the RegionInfo's were serialized to the stream with oDelimitedByteArray()
    
    Parameters:
    
    bytes - serialized bytes
    
    offset - the start offset into the byte[] buffer
    
    length - how far we should read into the byte[] buffer
    
    Returns:
    
    All the RegionInfos that are in the byte array. Keeps reading till we hit the end.
    
    Throws:
    
    IOException
  - isFirst
```
default boolean isFirst()
```
    Returns:
    
    True if this is first Region in Table
  - isLast
```
default boolean isLast()
```
    Returns:
    
    True if this is last Region in Table
  - isNext
```
default boolean isNext(RegionInfo after)
```
    Returns:
    
    True if region is next, adjacent but 'after' this one.
    
    See Also:
    
    isAdjacent(RegionInfo), areAdjacent(RegionInfo, RegionInfo)
  - isAdjacent
```
default boolean isAdjacent(RegionInfo other)
```
    Returns:
    
    True if region is adjacent, either just before or just after this one.
    
    See Also:
    
    isNext(RegionInfo)
  - isDegenerate
```
default boolean isDegenerate()
```
    Returns:
    
    True if RegionInfo is degenerate... if startKey > endKey.
  - isOverlap
```
default boolean isOverlap(RegionInfo other)
```
    Returns:
    
    True if an overlap in region range.
    
    See Also:
    
    isDegenerate()
  - compareTo
```
default int compareTo(RegionInfo other)
```
    Specified by:
    
    compareTo in interface Comparable<RegionInfo>

Interface RegionInfo

Method Summary

Method Detail

getShortNameToLog

getRegionId

getRegionName

getRegionNameAsString

getEncodedName

getEncodedNameAsBytes

getStartKey

getEndKey

getTable

getReplicaId

isSplit

isOffline

isSplitParent

isMetaRegion

containsRange

containsRow

getShortNameToLog

getShortNameToLog

getStartKey

areAdjacent

toByteArray

prettyPrint

createRegionName

createRegionName

createRegionName

createRegionName

createRegionName

createMobRegionInfo

parseRegionName

parseRegionNameOrReturnNull

toDelimitedByteArray

toDelimitedByteArray

parseFrom

parseDelimitedFrom

isFirst

isLast

isNext

isAdjacent

isDegenerate

isOverlap

compareTo