MetaTableAccessor (Apache HBase 1.2.12 API)

java.lang.Object
- org.apache.hadoop.hbase.MetaTableAccessor

```
@InterfaceAudience.Private
public class MetaTableAccessor
extends Object
```
Read/write operations on region and assignment information store in hbase:meta. Some of the methods of this class take ZooKeeperWatcher as a param. The only reason for this is because when used on client-side (like from HBaseAdmin), we want to use short-living connection (opened before each operation, closed right after), while when used on HM or HRS (like in AssignmentManager) we want permanent connection.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`(package private) static class`	`MetaTableAccessor.CollectAllVisitor` Collects all returned.
`(package private) static class`	`MetaTableAccessor.CollectingVisitor<T>` A `MetaTableAccessor.Visitor` that collects content out of passed `Result`.
`static interface`	`MetaTableAccessor.Visitor` Implementations 'visit' a catalog table row.

Field Summary

Fields
Modifier and Type	Field and Description
`private static org.apache.commons.logging.Log`	`LOG`
`(package private) static byte[]`	`META_REGION_PREFIX`
`protected static char`	`META_REPLICA_ID_DELIMITER` The delimiter for meta columns for replicaIds > 0
`private static Pattern`	`SERVER_COLUMN_PATTERN` A regex for parsing server columns from meta.

Constructor Summary

Constructors
Constructor and Description

MetaTableAccessor()

Constructors
Constructor and Description
`MetaTableAccessor()`

Method Summary

Methods
Modifier and Type	Method and Description
`static void`	`addDaughter(Connection connection, HRegionInfo regionInfo, ServerName sn, long openSeqNum)` Adds a daughter region entry to meta.
`static Put`	`addDaughtersToPut(Put put, HRegionInfo splitA, HRegionInfo splitB)` Adds split daughters to the Put
`static Put`	`addEmptyLocation(Put p, int replicaId)`
`static Put`	`addLocation(Put p, ServerName sn, long openSeqNum, long time, int replicaId)`
`private static Put`	`addRegionInfo(Put p, HRegionInfo hri)`
`static void`	`addRegionsToMeta(Connection connection, List<HRegionInfo> regionInfos, int regionReplication)` Adds a hbase:meta row for each of the specified new regions.
`static void`	`addRegionsToMeta(Connection connection, List<HRegionInfo> regionInfos, int regionReplication, long ts)` Adds a hbase:meta row for each of the specified new regions.
`static void`	`addRegionToMeta(Connection connection, HRegionInfo regionInfo)` Adds a hbase:meta row for the specified new region.
`static void`	`addRegionToMeta(Connection connection, HRegionInfo regionInfo, HRegionInfo splitA, HRegionInfo splitB)` Adds a (single) hbase:meta row for the specified new region and its daughters.
`static void`	`addRegionToMeta(Table meta, HRegionInfo regionInfo)` Adds a hbase:meta row for the specified new region to the given catalog table.
`static void`	`addRegionToMeta(Table meta, HRegionInfo regionInfo, HRegionInfo splitA, HRegionInfo splitB)` Adds a (single) hbase:meta row for the specified new region and its daughters.
`(package private) static void`	`deleteFromMetaTable(Connection connection, Delete d)` Delete the passed `d` from the `hbase:meta` table.
`static void`	`deleteFromMetaTable(Connection connection, List<Delete> deletes)` Delete the passed `deletes` from the `hbase:meta` table.
`static void`	`deleteMergeQualifiers(Connection connection, HRegionInfo mergedRegion)` Deletes merge qualifiers for the specified merged region.
`static void`	`deleteRegion(Connection connection, HRegionInfo regionInfo)` Deletes the specified region from META.
`static void`	`deleteRegions(Connection connection, List<HRegionInfo> regionsInfo)` Deletes the specified regions from META.
`static void`	`deleteRegions(Connection connection, List<HRegionInfo> regionsInfo, long ts)` Deletes the specified regions from META.
`static List<Result>`	`fullScan(Connection connection)` Performs a full scan of `hbase:meta`.
`static void`	`fullScan(Connection connection, MetaTableAccessor.Visitor visitor)` Performs a full scan of `hbase:meta`.
`static void`	`fullScan(Connection connection, MetaTableAccessor.Visitor visitor, byte[] startrow)` Performs a full scan of a catalog table.
`static void`	`fullScanMetaAndPrint(Connection connection)`
`static List<Result>`	`fullScanOfMeta(Connection connection)` Performs a full scan of a `hbase:meta` table.
`private static Result`	`get(Table t, Get g)`
`static PairOfSameType<HRegionInfo>`	`getDaughterRegions(Result data)` Returns the daughter regions by reading the corresponding columns of the catalog table Result.
`protected static byte[]`	`getFamily()` Returns the column family used for meta columns.
`static HRegionInfo`	`getHRegionInfo(Result data)` Returns HRegionInfo object from the column HConstants.CATALOG_FAMILY:HConstants.REGIONINFO_QUALIFIER of the catalog table Result.
`private static HRegionInfo`	`getHRegionInfo(Result r, byte[] qualifier)` Returns the HRegionInfo object from the column `HConstants.CATALOG_FAMILY` and `qualifier` of the catalog table result.
`(package private) static List<HRegionInfo>`	`getListOfHRegionInfos(List<Pair<HRegionInfo,ServerName>> pairs)`
`static PairOfSameType<HRegionInfo>`	`getMergeRegions(Result data)` Returns the merge regions by reading the corresponding columns of the catalog table Result.
`(package private) static Table`	`getMetaHTable(Connection connection)` Callers should call close on the returned `Table` instance.
`static byte[]`	`getMetaKeyForRegion(HRegionInfo regionInfo)` Returns the row key to use for this regionInfo
`static Pair<HRegionInfo,ServerName>`	`getRegion(Connection connection, byte[] regionName)` Deprecated. use `getRegionLocation(Connection, byte[])` instead
`static int`	`getRegionCount(org.apache.hadoop.conf.Configuration c, String tableName)` Deprecated.
`static int`	`getRegionCount(org.apache.hadoop.conf.Configuration c, TableName tableName)` Count regions in `hbase:meta` for passed table.
`static int`	`getRegionCount(Connection connection, TableName tableName)` Count regions in `hbase:meta` for passed table.
`protected static byte[]`	`getRegionInfoColumn()` Returns the column qualifier for serialized region info
`static HRegionLocation`	`getRegionLocation(Connection connection, byte[] regionName)` Returns the HRegionLocation from meta for the given region
`static HRegionLocation`	`getRegionLocation(Connection connection, HRegionInfo regionInfo)` Returns the HRegionLocation from meta for the given region
`private static HRegionLocation`	`getRegionLocation(Result r, HRegionInfo regionInfo, int replicaId)` Returns the HRegionLocation parsed from the given meta row Result for the given regionInfo and replicaId.
`static RegionLocations`	`getRegionLocations(Result r)` Returns an HRegionLocationList extracted from the result.
`static Result`	`getRegionResult(Connection connection, byte[] regionName)` Gets the result in hbase:meta for the specified region.
`static Pair<HRegionInfo,HRegionInfo>`	`getRegionsFromMergeQualifier(Connection connection, byte[] regionName)` Get regions from the merge qualifier of the specified merged region
`static Scan`	`getScanForTableName(TableName tableName)` This method creates a Scan object that will only scan catalog rows that belong to the specified table.
`static byte[]`	`getSeqNumColumn(int replicaId)` Returns the column qualifier for seqNum column for replicaId
`private static long`	`getSeqNumDuringOpen(Result r, int replicaId)` The latest seqnum that the server writing to meta observed when opening the region.
`static byte[]`	`getServerColumn(int replicaId)` Returns the column qualifier for server column for replicaId
`private static ServerName`	`getServerName(Result r, int replicaId)` Returns a `ServerName` from catalog table `Result`.
`static NavigableMap<HRegionInfo,Result>`	`getServerUserRegions(Connection connection, ServerName serverName)`
`static byte[]`	`getStartCodeColumn(int replicaId)` Returns the column qualifier for server start code column for replicaId
`static List<HRegionInfo>`	`getTableRegions(ZooKeeperWatcher zkw, Connection connection, TableName tableName)` Gets all of the regions of the specified table.
`static List<HRegionInfo>`	`getTableRegions(ZooKeeperWatcher zkw, Connection connection, TableName tableName, boolean excludeOfflinedSplitParents)` Gets all of the regions of the specified table.
`static List<Pair<HRegionInfo,ServerName>>`	`getTableRegionsAndLocations(ZooKeeperWatcher zkw, Connection connection, TableName tableName)`
`static List<Pair<HRegionInfo,ServerName>>`	`getTableRegionsAndLocations(ZooKeeperWatcher zkw, Connection connection, TableName tableName, boolean excludeOfflinedSplitParents)`
`(package private) static byte[]`	`getTableStartRowForMeta(TableName tableName)`
`(package private) static boolean`	`isInsideTable(HRegionInfo current, TableName tableName)`
`static Delete`	`makeDeleteFromRegionInfo(HRegionInfo regionInfo)` Generates and returns a Delete containing the region info for the catalog table
`static Delete`	`makeDeleteFromRegionInfo(HRegionInfo regionInfo, long ts)` Generates and returns a Delete containing the region info for the catalog table
`static Put`	`makePutFromRegionInfo(HRegionInfo regionInfo)` Generates and returns a Put containing the region into for the catalog table
`static Put`	`makePutFromRegionInfo(HRegionInfo regionInfo, long ts)` Generates and returns a Put containing the region into for the catalog table
`static void`	`mergeRegions(Connection connection, HRegionInfo mergedRegion, HRegionInfo regionA, HRegionInfo regionB, ServerName sn, int regionReplication, long masterSystemTime)` Merge the two regions into one in an atomic operation.
`private static void`	`multiMutate(Table table, byte[] row, Mutation... mutations)` Performs an atomic multi-Mutate operation against the given table.
`static void`	`mutateMetaTable(Connection connection, List<Mutation> mutations)` Execute the passed `mutations` against `hbase:meta` table.
`static void`	`mutateRegions(Connection connection, List<HRegionInfo> regionsToRemove, List<HRegionInfo> regionsToAdd)` Adds and Removes the specified regions from hbase:meta
`static void`	`overwriteRegions(Connection connection, List<HRegionInfo> regionInfos, int regionReplication)` Overwrites the specified regions from hbase:meta
`protected static HRegionInfo`	`parseRegionInfoFromRegionName(byte[] regionName)` Returns an HRI parsed from this regionName.
`(package private) static int`	`parseReplicaIdFromServerColumn(byte[] serverColumn)` Parses the replicaId from the server column qualifier.
`private static void`	`put(Table t, Put p)`
`static void`	`putsToMetaTable(Connection connection, List<Put> ps)` Put the passed `ps` to the `hbase:meta` table.
`(package private) static void`	`putToMetaTable(Connection connection, Put p)` Put the passed `p` to the `hbase:meta` table.
`static void`	`removeRegionReplicasFromMeta(Set<byte[]> metaRows, int replicaIndexToDeleteFrom, int numReplicasToRemove, Connection connection)` Deletes some replica columns corresponding to replicas for the passed rows
`static void`	`splitRegion(Connection connection, HRegionInfo parent, HRegionInfo splitA, HRegionInfo splitB, ServerName sn, int regionReplication)` Splits the region into two in an atomic operation.
`static boolean`	`tableExists(Connection connection, TableName tableName)` Checks if the specified table exists.
`private static void`	`updateLocation(Connection connection, HRegionInfo regionInfo, ServerName sn, long openSeqNum, long masterSystemTime)` Updates the location of the specified region to be the specified server.
`static void`	`updateRegionLocation(Connection connection, HRegionInfo regionInfo, ServerName sn, long openSeqNum, long masterSystemTime)` Updates the location of the specified region in hbase:meta to be the specified server hostname and startcode.

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

- Field Detail
  - LOG
```
private static final org.apache.commons.logging.Log LOG
```
  - META_REGION_PREFIX
```
static final byte[] META_REGION_PREFIX
```
  - META_REPLICA_ID_DELIMITER
```
protected static final char META_REPLICA_ID_DELIMITER
```
    The delimiter for meta columns for replicaIds > 0
    
    See Also:
    Constant Field Values
  - SERVER_COLUMN_PATTERN
```
private static final Pattern SERVER_COLUMN_PATTERN
```
    A regex for parsing server columns from meta. See above javadoc for meta layout
- Constructor Detail
  - MetaTableAccessor
```
public MetaTableAccessor()
```
- Method Detail
  - fullScanOfMeta
```
public static List<Result> fullScanOfMeta(Connection connection)
                                   throws IOException
```
    Performs a full scan of a hbase:meta table.
    
    Returns:
    List of Result
    
    Throws:
    
    IOException
  - fullScan
```
public static void fullScan(Connection connection,
            MetaTableAccessor.Visitor visitor)
                     throws IOException
```
    Performs a full scan of hbase:meta.
    
    Parameters:
    connection - connection we're using
    visitor - Visitor invoked against each row.
    
    Throws:
    
    IOException
  - fullScan
```
public static List<Result> fullScan(Connection connection)
                             throws IOException
```
    Performs a full scan of hbase:meta.
    
    Parameters:
    connection - connection we're using
    
    Returns:
    List of Result
    
    Throws:
    
    IOException
  - getMetaHTable
```
static Table getMetaHTable(Connection connection)
                    throws IOException
```
    Callers should call close on the returned Table instance.
    
    Parameters:
    connection - connection we're using to access Meta
    
    Returns:
    An Table for hbase:meta
    
    Throws:
    
    IOException
  - get
```
private static Result get(Table t,
         Get g)
                   throws IOException
```
    Parameters:
    t - Table to use (will be closed when done).
    g - Get to run
    
    Throws:
    
    IOException
  - getRegion
```
@Deprecated
public static Pair<HRegionInfo,ServerName> getRegion(Connection connection,
                                                byte[] regionName)
                                              throws IOException
```
    Deprecated. use getRegionLocation(Connection, byte[]) instead
    
    Gets the region info and assignment for the specified region.
    
    Parameters:
    connection - connection we're using
    regionName - Region to lookup.
    
    Returns:
    Location and HRegionInfo for regionName
    
    Throws:
    
    IOException
  - getRegionLocation
```
public static HRegionLocation getRegionLocation(Connection connection,
                                byte[] regionName)
                                         throws IOException
```
    Returns the HRegionLocation from meta for the given region
    
    Parameters:
    connection - connection we're using
    regionName - region we're looking for
    
    Returns:
    HRegionLocation for the given region
    
    Throws:
    
    IOException
  - getRegionLocation
```
public static HRegionLocation getRegionLocation(Connection connection,
                                HRegionInfo regionInfo)
                                         throws IOException
```
    Returns the HRegionLocation from meta for the given region
    
    Parameters:
    connection - connection we're using
    regionInfo - region information
    
    Returns:
    HRegionLocation for the given region
    
    Throws:
    
    IOException
  - getMetaKeyForRegion
```
public static byte[] getMetaKeyForRegion(HRegionInfo regionInfo)
```
    Returns the row key to use for this regionInfo
  - parseRegionInfoFromRegionName
```
protected static HRegionInfo parseRegionInfoFromRegionName(byte[] regionName)
                                                    throws IOException
```
    Returns an HRI parsed from this regionName. Not all the fields of the HRI is stored in the name, so the returned object should only be used for the fields in the regionName.
    
    Throws:
    
    IOException
  - getRegionResult
```
public static Result getRegionResult(Connection connection,
                     byte[] regionName)
                              throws IOException
```
    Gets the result in hbase:meta for the specified region.
    
    Parameters:
    connection - connection we're using
    regionName - region we're looking for
    
    Returns:
    result of the specified region
    
    Throws:
    
    IOException
  - getRegionsFromMergeQualifier
```
public static Pair<HRegionInfo,HRegionInfo> getRegionsFromMergeQualifier(Connection connection,
                                                         byte[] regionName)
                                                                  throws IOException
```
    Get regions from the merge qualifier of the specified merged region
    
    Returns:
    null if it doesn't contain merge qualifier, else two merge regions
    
    Throws:
    
    IOException
  - tableExists
```
public static boolean tableExists(Connection connection,
                  TableName tableName)
                           throws IOException
```
    Checks if the specified table exists. Looks at the hbase:meta table hosted on the specified server.
    
    Parameters:
    connection - connection we're using
    tableName - table to check
    
    Returns:
    true if the table exists in meta, false if not
    
    Throws:
    
    IOException
  - getTableRegions
```
public static List<HRegionInfo> getTableRegions(ZooKeeperWatcher zkw,
                                Connection connection,
                                TableName tableName)
                                         throws IOException
```
    Gets all of the regions of the specified table.
    
    Parameters:
    zkw - zookeeper connection to access meta table
    connection - connection we're using
    tableName - table we're looking for
    
    Returns:
    Ordered list of HRegionInfo.
    
    Throws:
    
    IOException
  - getTableRegions
```
public static List<HRegionInfo> getTableRegions(ZooKeeperWatcher zkw,
                                Connection connection,
                                TableName tableName,
                                boolean excludeOfflinedSplitParents)
                                         throws IOException
```
    Gets all of the regions of the specified table.
    
    Parameters:
    zkw - zookeeper connection to access meta table
    connection - connection we're using
    tableName - table we're looking for
    excludeOfflinedSplitParents - If true, do not include offlined split parents in the return.
    
    Returns:
    Ordered list of HRegionInfo.
    
    Throws:
    
    IOException
  - getListOfHRegionInfos
```
static List<HRegionInfo> getListOfHRegionInfos(List<Pair<HRegionInfo,ServerName>> pairs)
```
  - isInsideTable
```
static boolean isInsideTable(HRegionInfo current,
                    TableName tableName)
```
    Parameters:
    current - region of current table we're working with
    tableName - table we're checking against
    
    Returns:
    True if current tablename is equal to tableName
  - getTableStartRowForMeta
```
static byte[] getTableStartRowForMeta(TableName tableName)
```
    Parameters:
    tableName - table we're working with
    
    Returns:
    Place to start Scan in hbase:meta when passed a tableName; returns <tableName&rt; <,&rt; <,&rt;
  - getScanForTableName
```
public static Scan getScanForTableName(TableName tableName)
```
    This method creates a Scan object that will only scan catalog rows that belong to the specified table. It doesn't specify any columns. This is a better alternative to just using a start row and scan until it hits a new table since that requires parsing the HRI to get the table name.
    
    Parameters:
    tableName - bytes of table's name
    
    Returns:
    configured Scan object
  - getTableRegionsAndLocations
```
public static List<Pair<HRegionInfo,ServerName>> getTableRegionsAndLocations(ZooKeeperWatcher zkw,
                                                             Connection connection,
                                                             TableName tableName)
                                                                      throws IOException
```
    Parameters:
    zkw - zookeeper connection to access meta table
    connection - connection we're using
    tableName - table we're looking for
    
    Returns:
    Return list of regioninfos and server.
    
    Throws:
    
    IOException
  - getTableRegionsAndLocations
```
public static List<Pair<HRegionInfo,ServerName>> getTableRegionsAndLocations(ZooKeeperWatcher zkw,
                                                             Connection connection,
                                                             TableName tableName,
                                                             boolean excludeOfflinedSplitParents)
                                                                      throws IOException
```
    Parameters:
    zkw - ZooKeeperWatcher instance we're using to get hbase:meta location
    connection - connection we're using
    tableName - table to work with
    
    Returns:
    Return list of regioninfos and server addresses.
    
    Throws:
    
    IOException
  - getServerUserRegions
```
public static NavigableMap<HRegionInfo,Result> getServerUserRegions(Connection connection,
                                                    ServerName serverName)
                                                             throws IOException
```
    Parameters:
    connection - connection we're using
    serverName - server whose regions we're interested in
    
    Returns:
    List of user regions installed on this server (does not include catalog regions).
    
    Throws:
    
    IOException
  - fullScanMetaAndPrint
```
public static void fullScanMetaAndPrint(Connection connection)
                                 throws IOException
```
    Throws:
    
    IOException
  - fullScan
```
public static void fullScan(Connection connection,
            MetaTableAccessor.Visitor visitor,
            byte[] startrow)
                     throws IOException
```
    Performs a full scan of a catalog table.
    
    Parameters:
    connection - connection we're using
    visitor - Visitor invoked against each row.
    startrow - Where to start the scan. Pass null if want to begin scan at first row. hbase:meta, the default (pass false to scan hbase:meta)
    
    Throws:
    
    IOException
  - getFamily
```
protected static byte[] getFamily()
```
    Returns the column family used for meta columns.
    
    Returns:
    HConstants.CATALOG_FAMILY.
  - getRegionInfoColumn
```
protected static byte[] getRegionInfoColumn()
```
    Returns the column qualifier for serialized region info
    
    Returns:
    HConstants.REGIONINFO_QUALIFIER
  - getServerColumn
```
public static byte[] getServerColumn(int replicaId)
```
    Returns the column qualifier for server column for replicaId
    
    Parameters:
    replicaId - the replicaId of the region
    
    Returns:
    a byte[] for server column qualifier
  - getStartCodeColumn
```
public static byte[] getStartCodeColumn(int replicaId)
```
    Returns the column qualifier for server start code column for replicaId
    
    Parameters:
    replicaId - the replicaId of the region
    
    Returns:
    a byte[] for server start code column qualifier
  - getSeqNumColumn
```
public static byte[] getSeqNumColumn(int replicaId)
```
    Returns the column qualifier for seqNum column for replicaId
    
    Parameters:
    replicaId - the replicaId of the region
    
    Returns:
    a byte[] for seqNum column qualifier
  - parseReplicaIdFromServerColumn
```
static int parseReplicaIdFromServerColumn(byte[] serverColumn)
```
    Parses the replicaId from the server column qualifier. See top of the class javadoc for the actual meta layout
    
    Parameters:
    serverColumn - the column qualifier
    
    Returns:
    an int for the replicaId
  - getServerName
```
private static ServerName getServerName(Result r,
                       int replicaId)
```
    Returns a ServerName from catalog table Result.
    
    Parameters:
    r - Result to pull from
    
    Returns:
    A ServerName instance or null if necessary fields not found or empty.
  - getSeqNumDuringOpen
```
private static long getSeqNumDuringOpen(Result r,
                       int replicaId)
```
    The latest seqnum that the server writing to meta observed when opening the region. E.g. the seqNum when the result of getServerName(Result, int) was written.
    
    Parameters:
    r - Result to pull the seqNum from
    
    Returns:
    SeqNum, or HConstants.NO_SEQNUM if there's no value written.
  - getRegionLocations
```
public static RegionLocations getRegionLocations(Result r)
```
    Returns an HRegionLocationList extracted from the result.
    
    Returns:
    an HRegionLocationList containing all locations for the region range or null if we can't deserialize the result.
  - getRegionLocation
```
private static HRegionLocation getRegionLocation(Result r,
                                HRegionInfo regionInfo,
                                int replicaId)
```
    Returns the HRegionLocation parsed from the given meta row Result for the given regionInfo and replicaId. The regionInfo can be the default region info for the replica.
    
    Parameters:
    r - the meta row result
    regionInfo - RegionInfo for default replica
    replicaId - the replicaId for the HRegionLocation
    
    Returns:
    HRegionLocation parsed from the given meta row Result for the given replicaId
  - getHRegionInfo
```
public static HRegionInfo getHRegionInfo(Result data)
```
    Returns HRegionInfo object from the column HConstants.CATALOG_FAMILY:HConstants.REGIONINFO_QUALIFIER of the catalog table Result.
    
    Parameters:
    data - a Result object from the catalog table scan
    
    Returns:
    HRegionInfo or null
  - getHRegionInfo
```
private static HRegionInfo getHRegionInfo(Result r,
                         byte[] qualifier)
```
    Returns the HRegionInfo object from the column HConstants.CATALOG_FAMILY and qualifier of the catalog table result.
    
    Parameters:
    r - a Result object from the catalog table scan
    qualifier - Column family qualifier
    
    Returns:
    An HRegionInfo instance or null.
  - getDaughterRegions
```
public static PairOfSameType<HRegionInfo> getDaughterRegions(Result data)
```
    Returns the daughter regions by reading the corresponding columns of the catalog table Result.
    
    Parameters:
    data - a Result object from the catalog table scan
    
    Returns:
    a pair of HRegionInfo or PairOfSameType(null, null) if the region is not a split parent
  - getMergeRegions
```
public static PairOfSameType<HRegionInfo> getMergeRegions(Result data)
```
    Returns the merge regions by reading the corresponding columns of the catalog table Result.
    
    Parameters:
    data - a Result object from the catalog table scan
    
    Returns:
    a pair of HRegionInfo or PairOfSameType(null, null) if the region is not a split parent
  - getRegionCount
```
@Deprecated
public static int getRegionCount(org.apache.hadoop.conf.Configuration c,
                            String tableName)
                          throws IOException
```
    Deprecated.
    
    Count regions in hbase:meta for passed table.
    
    Parameters:
    c - Configuration object
    tableName - table name to count regions for
    
    Returns:
    Count or regions in table tableName
    
    Throws:
    
    IOException
  - getRegionCount
```
public static int getRegionCount(org.apache.hadoop.conf.Configuration c,
                 TableName tableName)
                          throws IOException
```
    Count regions in hbase:meta for passed table.
    
    Parameters:
    c - Configuration object
    tableName - table name to count regions for
    
    Returns:
    Count or regions in table tableName
    
    Throws:
    
    IOException
  - getRegionCount
```
public static int getRegionCount(Connection connection,
                 TableName tableName)
                          throws IOException
```
    Count regions in hbase:meta for passed table.
    
    Parameters:
    connection - Connection object
    tableName - table name to count regions for
    
    Returns:
    Count or regions in table tableName
    
    Throws:
    
    IOException
  - makePutFromRegionInfo
```
public static Put makePutFromRegionInfo(HRegionInfo regionInfo)
                                 throws IOException
```
    Generates and returns a Put containing the region into for the catalog table
    
    Throws:
    
    IOException
  - makePutFromRegionInfo
```
public static Put makePutFromRegionInfo(HRegionInfo regionInfo,
                        long ts)
                                 throws IOException
```
    Generates and returns a Put containing the region into for the catalog table
    
    Throws:
    
    IOException
  - makeDeleteFromRegionInfo
```
public static Delete makeDeleteFromRegionInfo(HRegionInfo regionInfo)
```
    Generates and returns a Delete containing the region info for the catalog table
  - makeDeleteFromRegionInfo
```
public static Delete makeDeleteFromRegionInfo(HRegionInfo regionInfo,
                              long ts)
```
    Generates and returns a Delete containing the region info for the catalog table
  - addDaughtersToPut
```
public static Put addDaughtersToPut(Put put,
                    HRegionInfo splitA,
                    HRegionInfo splitB)
```
    Adds split daughters to the Put
  - putToMetaTable
```
static void putToMetaTable(Connection connection,
                  Put p)
                    throws IOException
```
    Put the passed p to the hbase:meta table.
    
    Parameters:
    connection - connection we're using
    p - Put to add to hbase:meta
    
    Throws:
    
    IOException
  - put
```
private static void put(Table t,
       Put p)
                 throws IOException
```
    Parameters:
    t - Table to use (will be closed when done).
    p - put to make
    
    Throws:
    
    IOException
  - putsToMetaTable
```
public static void putsToMetaTable(Connection connection,
                   List<Put> ps)
                            throws IOException
```
    Put the passed ps to the hbase:meta table.
    
    Parameters:
    connection - connection we're using
    ps - Put to add to hbase:meta
    
    Throws:
    
    IOException
  - deleteFromMetaTable
```
static void deleteFromMetaTable(Connection connection,
                       Delete d)
                         throws IOException
```
    Delete the passed d from the hbase:meta table.
    
    Parameters:
    connection - connection we're using
    d - Delete to add to hbase:meta
    
    Throws:
    
    IOException
  - deleteFromMetaTable
```
public static void deleteFromMetaTable(Connection connection,
                       List<Delete> deletes)
                                throws IOException
```
    Delete the passed deletes from the hbase:meta table.
    
    Parameters:
    connection - connection we're using
    deletes - Deletes to add to hbase:meta This list should support #remove.
    
    Throws:
    
    IOException
  - removeRegionReplicasFromMeta
```
public static void removeRegionReplicasFromMeta(Set<byte[]> metaRows,
                                int replicaIndexToDeleteFrom,
                                int numReplicasToRemove,
                                Connection connection)
                                         throws IOException
```
    Deletes some replica columns corresponding to replicas for the passed rows
    
    Parameters:
    metaRows - rows in hbase:meta
    replicaIndexToDeleteFrom - the replica ID we would start deleting from
    numReplicasToRemove - how many replicas to remove
    connection - connection we're using to access meta table
    
    Throws:
    
    IOException
  - mutateMetaTable
```
public static void mutateMetaTable(Connection connection,
                   List<Mutation> mutations)
                            throws IOException
```
    Execute the passed mutations against hbase:meta table.
    
    Parameters:
    connection - connection we're using
    mutations - Puts and Deletes to execute on hbase:meta
    
    Throws:
    
    IOException
  - addRegionToMeta
```
public static void addRegionToMeta(Connection connection,
                   HRegionInfo regionInfo)
                            throws IOException
```
    Adds a hbase:meta row for the specified new region.
    
    Parameters:
    connection - connection we're using
    regionInfo - region information
    
    Throws:
    
    IOException - if problem connecting or updating meta
  - addRegionToMeta
```
public static void addRegionToMeta(Table meta,
                   HRegionInfo regionInfo)
                            throws IOException
```
    Adds a hbase:meta row for the specified new region to the given catalog table. The Table is not flushed or closed.
    
    Parameters:
    meta - the Table for META
    regionInfo - region information
    
    Throws:
    
    IOException - if problem connecting or updating meta
  - addRegionToMeta
```
public static void addRegionToMeta(Table meta,
                   HRegionInfo regionInfo,
                   HRegionInfo splitA,
                   HRegionInfo splitB)
                            throws IOException
```
    Adds a (single) hbase:meta row for the specified new region and its daughters. Note that this does not add its daughter's as different rows, but adds information about the daughters in the same row as the parent. Use splitRegion(Connection, HRegionInfo, HRegionInfo, HRegionInfo, ServerName, int) if you want to do that.
    
    Parameters:
    meta - the Table for META
    regionInfo - region information
    splitA - first split daughter of the parent regionInfo
    splitB - second split daughter of the parent regionInfo
    
    Throws:
    
    IOException - if problem connecting or updating meta
  - addRegionToMeta
```
public static void addRegionToMeta(Connection connection,
                   HRegionInfo regionInfo,
                   HRegionInfo splitA,
                   HRegionInfo splitB)
                            throws IOException
```
    Adds a (single) hbase:meta row for the specified new region and its daughters. Note that this does not add its daughter's as different rows, but adds information about the daughters in the same row as the parent. Use splitRegion(Connection, HRegionInfo, HRegionInfo, HRegionInfo, ServerName, int) if you want to do that.
    
    Parameters:
    connection - connection we're using
    regionInfo - region information
    splitA - first split daughter of the parent regionInfo
    splitB - second split daughter of the parent regionInfo
    
    Throws:
    
    IOException - if problem connecting or updating meta
  - addRegionsToMeta
```
public static void addRegionsToMeta(Connection connection,
                    List<HRegionInfo> regionInfos,
                    int regionReplication)
                             throws IOException
```
    Adds a hbase:meta row for each of the specified new regions.
    
    Parameters:
    connection - connection we're using
    regionInfos - region information list
    
    Throws:
    
    IOException - if problem connecting or updating meta
  - addRegionsToMeta
```
public static void addRegionsToMeta(Connection connection,
                    List<HRegionInfo> regionInfos,
                    int regionReplication,
                    long ts)
                             throws IOException
```
    Adds a hbase:meta row for each of the specified new regions.
    
    Parameters:
    connection - connection we're using
    regionInfos - region information list
    regionReplication -
    ts - desired timestamp
    
    Throws:
    
    IOException - if problem connecting or updating meta
  - addDaughter
```
public static void addDaughter(Connection connection,
               HRegionInfo regionInfo,
               ServerName sn,
               long openSeqNum)
                        throws NotAllMetaRegionsOnlineException,
                               IOException
```
    Adds a daughter region entry to meta.
    
    Parameters:
    regionInfo - the region to put
    sn - the location of the region
    openSeqNum - the latest sequence number obtained when the region was open
    
    Throws:
    
    NotAllMetaRegionsOnlineException
    
    IOException
  - mergeRegions
```
public static void mergeRegions(Connection connection,
                HRegionInfo mergedRegion,
                HRegionInfo regionA,
                HRegionInfo regionB,
                ServerName sn,
                int regionReplication,
                long masterSystemTime)
                         throws IOException
```
    Merge the two regions into one in an atomic operation. Deletes the two merging regions in hbase:meta and adds the merged region with the information of two merging regions.
    
    Parameters:
    connection - connection we're using
    mergedRegion - the merged region
    regionA -
    regionB -
    sn - the location of the region
    masterSystemTime -
    
    Throws:
    
    IOException
  - splitRegion
```
public static void splitRegion(Connection connection,
               HRegionInfo parent,
               HRegionInfo splitA,
               HRegionInfo splitB,
               ServerName sn,
               int regionReplication)
                        throws IOException
```
    Splits the region into two in an atomic operation. Offlines the parent region with the information that it is split into two, and also adds the daughter regions. Does not add the location information to the daughter regions since they are not open yet.
    
    Parameters:
    connection - connection we're using
    parent - the parent region which is split
    splitA - Split daughter region A
    splitB - Split daughter region A
    sn - the location of the region
    
    Throws:
    
    IOException
  - multiMutate
```
private static void multiMutate(Table table,
               byte[] row,
               Mutation... mutations)
                         throws IOException
```
    Performs an atomic multi-Mutate operation against the given table.
    
    Throws:
    
    IOException
  - updateRegionLocation
```
public static void updateRegionLocation(Connection connection,
                        HRegionInfo regionInfo,
                        ServerName sn,
                        long openSeqNum,
                        long masterSystemTime)
                                 throws IOException
```
    Updates the location of the specified region in hbase:meta to be the specified server hostname and startcode.
    Uses passed catalog tracker to get a connection to the server hosting hbase:meta and makes edits to that region.
    
    Parameters:
    connection - connection we're using
    regionInfo - region to update location of
    openSeqNum - the latest sequence number obtained when the region was open
    sn - Server name
    masterSystemTime - wall clock time from master if passed in the open region RPC or -1
    
    Throws:
    
    IOException
  - updateLocation
```
private static void updateLocation(Connection connection,
                  HRegionInfo regionInfo,
                  ServerName sn,
                  long openSeqNum,
                  long masterSystemTime)
                            throws IOException
```
    Updates the location of the specified region to be the specified server.
    Connects to the specified server which should be hosting the specified catalog region name to perform the edit.
    
    Parameters:
    connection - connection we're using
    regionInfo - region to update location of
    sn - Server name
    openSeqNum - the latest sequence number obtained when the region was open
    masterSystemTime - wall clock time from master if passed in the open region RPC or -1
    
    Throws:
    
    IOException - In particular could throw ConnectException if the server is down on other end.
  - deleteRegion
```
public static void deleteRegion(Connection connection,
                HRegionInfo regionInfo)
                         throws IOException
```
    Deletes the specified region from META.
    
    Parameters:
    connection - connection we're using
    regionInfo - region to be deleted from META
    
    Throws:
    
    IOException
  - deleteRegions
```
public static void deleteRegions(Connection connection,
                 List<HRegionInfo> regionsInfo,
                 long ts)
                          throws IOException
```
    Deletes the specified regions from META.
    
    Parameters:
    connection - connection we're using
    regionsInfo - list of regions to be deleted from META
    ts - desired timestamp
    
    Throws:
    
    IOException
  - deleteRegions
```
public static void deleteRegions(Connection connection,
                 List<HRegionInfo> regionsInfo)
                          throws IOException
```
    Deletes the specified regions from META.
    
    Parameters:
    connection - connection we're using
    regionsInfo - list of regions to be deleted from META
    
    Throws:
    
    IOException
  - mutateRegions
```
public static void mutateRegions(Connection connection,
                 List<HRegionInfo> regionsToRemove,
                 List<HRegionInfo> regionsToAdd)
                          throws IOException
```
    Adds and Removes the specified regions from hbase:meta
    
    Parameters:
    connection - connection we're using
    regionsToRemove - list of regions to be deleted from META
    regionsToAdd - list of regions to be added to META
    
    Throws:
    
    IOException
  - overwriteRegions
```
public static void overwriteRegions(Connection connection,
                    List<HRegionInfo> regionInfos,
                    int regionReplication)
                             throws IOException
```
    Overwrites the specified regions from hbase:meta
    
    Parameters:
    connection - connection we're using
    regionInfos - list of regions to be added to META
    
    Throws:
    
    IOException
  - deleteMergeQualifiers
```
public static void deleteMergeQualifiers(Connection connection,
                         HRegionInfo mergedRegion)
                                  throws IOException
```
    Deletes merge qualifiers for the specified merged region.
    
    Parameters:
    connection - connection we're using
    mergedRegion -
    
    Throws:
    
    IOException
  - addRegionInfo
```
private static Put addRegionInfo(Put p,
                HRegionInfo hri)
                          throws IOException
```
    Throws:
    
    IOException
  - addLocation
```
public static Put addLocation(Put p,
              ServerName sn,
              long openSeqNum,
              long time,
              int replicaId)
```
  - addEmptyLocation
```
public static Put addEmptyLocation(Put p,
                   int replicaId)
```

Class MetaTableAccessor

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LOG

META_REGION_PREFIX

META_REPLICA_ID_DELIMITER

SERVER_COLUMN_PATTERN

Constructor Detail

MetaTableAccessor

Method Detail

fullScanOfMeta

fullScan

fullScan

getMetaHTable

get

getRegion

getRegionLocation

getRegionLocation

getMetaKeyForRegion

parseRegionInfoFromRegionName

getRegionResult

getRegionsFromMergeQualifier

tableExists

getTableRegions

getTableRegions

getListOfHRegionInfos

isInsideTable

getTableStartRowForMeta

getScanForTableName

getTableRegionsAndLocations

getTableRegionsAndLocations

getServerUserRegions

fullScanMetaAndPrint

fullScan

getFamily

getRegionInfoColumn

getServerColumn

getStartCodeColumn

getSeqNumColumn

parseReplicaIdFromServerColumn

getServerName

getSeqNumDuringOpen

getRegionLocations

getRegionLocation

getHRegionInfo

getHRegionInfo

getDaughterRegions

getMergeRegions

getRegionCount

getRegionCount

getRegionCount

makePutFromRegionInfo

makePutFromRegionInfo

makeDeleteFromRegionInfo

makeDeleteFromRegionInfo

addDaughtersToPut

putToMetaTable

put

putsToMetaTable

deleteFromMetaTable

deleteFromMetaTable

removeRegionReplicasFromMeta

mutateMetaTable

addRegionToMeta

addRegionToMeta

addRegionToMeta

addRegionToMeta

addRegionsToMeta

addRegionsToMeta

addDaughter

mergeRegions

splitRegion

multiMutate

updateRegionLocation

updateLocation

deleteRegion