MetaTableAccessor (Apache HBase 2.0.6 API)

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

@InterfaceAudience.Private
public class MetaTableAccessor
extends Object

Read/write operations on hbase:meta region as well as assignment information stored to hbase:meta.

Some of the methods of this class take ZooKeeperWatcher as a param. The only reason for this is when this class is used on client-side (e.g. HBaseAdmin), we want to use short-lived connection (opened before each operation, closed right after), while when used on HM or HRS (like in AssignmentManager) we want permanent connection.

HBASE-10070 adds a replicaId to HRI, meaning more than one HRI can be defined for the same table range (table, startKey, endKey). For every range, there will be at least one HRI defined which is called default replica.

Meta layout

 For each table there is single row named for the table with a 'table' column family.
 The column family currently has one column in it, the 'state' column:

 table:state             => contains table state

 Then for each table range ('Region'), there is a single row, formatted as:
 <tableName>,<startKey>,<regionId>,<encodedRegionName>.
 This row is the serialized regionName of the default region replica.
 Columns are:
 info:regioninfo         => contains serialized HRI for the default region replica
 info:server             => contains hostname:port (in string form) for the server hosting
                            the default regionInfo replica
 info:server_<replicaId> => contains hostname:port (in string form) for the server hosting
                                 the regionInfo replica with replicaId
 info:serverstartcode    => contains server start code (in binary long form) for the server
                            hosting the default regionInfo replica
 info:serverstartcode_<replicaId> => contains server start code (in binary long form) for
                                          the server hosting the regionInfo replica with
                                          replicaId
 info:seqnumDuringOpen   => contains seqNum (in binary long form) for the region at the time
                             the server opened the region with default replicaId
 info:seqnumDuringOpen_<replicaId> => contains seqNum (in binary long form) for the region
                                           at the time the server opened the region with
                                           replicaId
 info:splitA             => contains a serialized HRI for the first daughter region if the
                             region is split
 info:splitB             => contains a serialized HRI for the second daughter region if the
                             region is split
 info:merge*             => contains a serialized HRI for a merge parent region. There will be two
                             or more of these columns in a row. A row that has these columns is
                             undergoing a merge and is the result of the merge. Columns listed
                             in marge* columns are the parents of this merged region. Example
                             columns: info:merge0001, info:merge0002. You make also see 'mergeA',
                             and 'mergeB'. This is old form replaced by the new format that allows
                             for more than two parents to be merged at a time.
 TODO: Add rep_barrier for serial replication explaination.

The actual layout of meta should be encapsulated inside MetaTableAccessor methods, and should not leak out of it (through Result objects, etc)

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static interface`	`MetaTableAccessor.CloseableVisitor` Implementations 'visit' a catalog table row but with close() at the end.
`(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 class`	`MetaTableAccessor.DefaultVisitorBase` A Visitor that skips offline regions and split parents
`static class`	`MetaTableAccessor.QueryType`
`static class`	`MetaTableAccessor.TableVisitorBase` A Visitor for a table.
`static interface`	`MetaTableAccessor.Visitor` Implementations 'visit' a catalog table row.

Field Summary

Fields
Modifier and Type	Field and Description
`private static byte`	`ESCAPE_BYTE`
`private static org.slf4j.Logger`	`LOG`
`(package private) static char`	`META_REPLICA_ID_DELIMITER` The delimiter for meta columns for replicaIds > 0
`private static org.slf4j.Logger`	`METALOG`
`static byte[]`	`REPLICATION_PARENT_QUALIFIER`
`private static byte`	`SEPARATED_BYTE`
`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

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`private static Put`	`addDaughtersToPut(Put put, RegionInfo splitA, RegionInfo splitB)` Adds split daughters to the Put
`private static Put`	`addEmptyLocation(Put p, int replicaId)`
`static Put`	`addLocation(Put p, ServerName sn, long openSeqNum, int replicaId)`
`(package private) static Put`	`addMergeRegions(Put put, Collection<RegionInfo> mergeRegions)`
`static Put`	`addRegionInfo(Put p, RegionInfo hri)`
`private static void`	`addRegionStateToPut(Put put, RegionState.State state)`
`static void`	`addRegionsToMeta(Connection connection, List<RegionInfo> regionInfos, int regionReplication)` Adds a hbase:meta row for each of the specified new regions.
`private static void`	`addRegionsToMeta(Connection connection, List<RegionInfo> regionInfos, int regionReplication, long ts)` Adds a hbase:meta row for each of the specified new regions.
`static void`	`addRegionToMeta(Connection connection, RegionInfo regionInfo)` Adds a (single) hbase:meta row for the specified new region and its daughters.
`private static Put`	`addSequenceNum(Put p, long openSeqNum, int replicaId)`
`static void`	`addSplitsToParent(Connection connection, RegionInfo regionInfo, RegionInfo splitA, RegionInfo splitB)` Adds daughter region infos to hbase:meta row for the specified region.
`static NavigableMap<RegionInfo,ServerName>`	`allTableRegions(Connection connection, TableName tableName)` Deprecated. use `getTableRegionsAndLocations(org.apache.hadoop.hbase.client.Connection, org.apache.hadoop.hbase.TableName)`, region can have multiple locations
`private static void`	`debugLogMutation(Mutation p)`
`private static void`	`debugLogMutations(List<? extends Mutation> mutations)`
`private static void`	`deleteFromMetaTable(Connection connection, Delete d)` Delete the passed `d` from the `hbase:meta` table.
`private static void`	`deleteFromMetaTable(Connection connection, List<Delete> deletes)` Delete the passed `deletes` from the `hbase:meta` table.
`static void`	`deleteMergeQualifiers(Connection connection, RegionInfo mergeRegion)` Deletes merge qualifiers for the specified merge region.
`static void`	`deleteRegionInfo(Connection connection, RegionInfo regionInfo)` Deletes the specified region from META.
`static void`	`deleteRegionInfos(Connection connection, List<RegionInfo> regionsInfo)` Deletes the specified regions from META.
`private static void`	`deleteRegionInfos(Connection connection, List<RegionInfo> regionsInfo, long ts)` Deletes the specified regions from META.
`static void`	`deleteTableState(Connection connection, TableName table)` Remove state for table from meta
`private static List<Result>`	`fullScan(Connection connection, MetaTableAccessor.QueryType type)` Performs a full scan of `hbase:meta`.
`static void`	`fullScanMetaAndPrint(Connection connection)`
`static List<Result>`	`fullScanRegions(Connection connection)` Performs a full scan of `hbase:meta` for regions.
`static void`	`fullScanRegions(Connection connection, MetaTableAccessor.Visitor visitor)` Performs a full scan of `hbase:meta` for regions.
`static void`	`fullScanTables(Connection connection, MetaTableAccessor.Visitor visitor)` Performs a full scan of `hbase:meta` for tables.
`private static Result`	`get(Table t, Get g)`
`static List<RegionInfo>`	`getAllRegions(Connection connection, boolean excludeOfflinedSplitParents)` Lists all of the regions currently in META.
`static byte[]`	`getCatalogFamily()` Returns the column family used for meta columns.
`private static RegionInfo`	`getClosestRegionInfo(Connection connection, TableName tableName, byte[] row)`
`static PairOfSameType<RegionInfo>`	`getDaughterRegions(Result data)` Returns the daughter regions by reading the corresponding columns of the catalog table Result.
`private static List<RegionInfo>`	`getListOfRegionInfos(List<Pair<RegionInfo,ServerName>> pairs)`
`static List<RegionInfo>`	`getMergeRegions(Cell[] cells)`
`static List<RegionInfo>`	`getMergeRegions(Connection connection, byte[] regionName)`
`private static Cell[]`	`getMergeRegionsRaw(Connection connection, byte[] regionName)`
`static Table`	`getMetaHTable(Connection connection)` Callers should call close on the returned `Table` instance.
`static byte[]`	`getMetaKeyForRegion(RegionInfo regionInfo)` Returns the row key to use for this regionInfo
`private static Scan`	`getMetaScan(Connection connection, int rowUpperLimit)`
`static Pair<RegionInfo,ServerName>`	`getRegion(Connection connection, byte[] regionName)` Deprecated. use `getRegionLocation(Connection, byte[])` instead
`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.
`static RegionInfo`	`getRegionInfo(Result data)` Returns RegionInfo object from the column HConstants.CATALOG_FAMILY:HConstants.REGIONINFO_QUALIFIER of the catalog table Result.
`static RegionInfo`	`getRegionInfo(Result r, byte[] qualifier)` Returns the RegionInfo object from the column `HConstants.CATALOG_FAMILY` and `qualifier` of the catalog table result.
`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, RegionInfo regionInfo)` Returns the HRegionLocation from meta for the given region
`private static HRegionLocation`	`getRegionLocation(Result r, RegionInfo 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.
`private static byte[]`	`getRegionStateColumn()` Returns the column qualifier for serialized region state
`(package private) static byte[]`	`getRegionStateColumn(int replicaId)` Returns the column qualifier for serialized region state
`static Scan`	`getScanForTableName(Connection connection, TableName tableName)` Deprecated.
`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
`static ServerName`	`getServerName(Result r, int replicaId)` Returns a `ServerName` from catalog table `Result`.
`(package private) static byte[]`	`getServerNameColumn(int replicaId)` Returns the column qualifier for serialized region state
`static NavigableMap<RegionInfo,Result>`	`getServerUserRegions(Connection connection, ServerName serverName)`
`static byte[]`	`getStartCodeColumn(int replicaId)` Returns the column qualifier for server start code column for replicaId
`private static byte[]`	`getTableFamily()` Returns the column family used for table columns.
`static List<RegionInfo>`	`getTableRegions(Connection connection, TableName tableName)` Gets all of the regions of the specified table.
`static List<RegionInfo>`	`getTableRegions(Connection connection, TableName tableName, boolean excludeOfflinedSplitParents)` Gets all of the regions of the specified table.
`static List<Pair<RegionInfo,ServerName>>`	`getTableRegionsAndLocations(Connection connection, TableName tableName)` Do not use this method to get meta table regions, use methods in MetaTableLocator instead.
`static List<Pair<RegionInfo,ServerName>>`	`getTableRegionsAndLocations(Connection connection, TableName tableName, boolean excludeOfflinedSplitParents)` Do not use this method to get meta table regions, use methods in MetaTableLocator instead.
`static byte[]`	`getTableStartRowForMeta(TableName tableName, MetaTableAccessor.QueryType type)`
`static TableState`	`getTableState(Connection conn, TableName tableName)` Fetch table state for given table from META table
`static TableState`	`getTableState(Result r)` Decode table state from META Result.
`private static byte[]`	`getTableStateColumn()` Returns the column qualifier for serialized table state
`static Map<TableName,TableState>`	`getTableStates(Connection conn)` Fetch table states from META table
`static byte[]`	`getTableStopRowForMeta(TableName tableName, MetaTableAccessor.QueryType type)`
`static boolean`	`hasMergeRegions(Cell[] cells)`
`private static boolean`	`isMergeQualifierPrefix(Cell cell)`
`private static Delete`	`makeDeleteFromRegionInfo(RegionInfo regionInfo, long ts)` Generates and returns a Delete containing the region info for the catalog table
`static Put`	`makePutFromRegionInfo(RegionInfo regionInfo, long ts)` Generates and returns a Put containing the region into for the catalog table
`static Put`	`makePutFromTableState(TableState state, long ts)` Construct PUT for given state
`static void`	`mergeRegions(Connection connection, RegionInfo mergedRegion, RegionInfo[] parents, ServerName sn, int regionReplication)` Merge regions into one in an atomic operation.
`static void`	`multiMutate(Connection connection, Table table, byte[] row, List<Mutation> mutations)` Performs an atomic multi-mutate operation against the given table.
`private static void`	`multiMutate(Connection connection, Table table, byte[] row, Mutation... mutations)`
`static void`	`overwriteRegions(Connection connection, List<RegionInfo> regionInfos, int regionReplication)` Overwrites the specified regions from hbase:meta.
`static RegionInfo`	`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.
`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 Result`	`scanByRegionEncodedName(Connection connection, String regionEncodedName)` Scans META table for a row whose key contains the specified regionEncodedName, returning a single related `Result` instance if any row is found, null otherwise.
`(package private) static void`	`scanMeta(Connection connection, byte[] startRow, byte[] stopRow, MetaTableAccessor.QueryType type, int maxRows, MetaTableAccessor.Visitor visitor)` Performs a scan of META table.
`private static void`	`scanMeta(Connection connection, byte[] startRow, byte[] stopRow, MetaTableAccessor.QueryType type, MetaTableAccessor.Visitor visitor)`
`static void`	`scanMeta(Connection connection, MetaTableAccessor.Visitor visitor, TableName tableName, byte[] row, int rowLimit)` Performs a scan of META table for given table starting from given row.
`private static void`	`scanMeta(Connection connection, TableName table, MetaTableAccessor.QueryType type, int maxRows, MetaTableAccessor.Visitor visitor)`
`static void`	`scanMetaForTableRegions(Connection connection, MetaTableAccessor.Visitor visitor, TableName tableName)`
`static void`	`splitRegion(Connection connection, RegionInfo parent, RegionInfo splitA, RegionInfo 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, RegionInfo regionInfo, ServerName sn, long openSeqNum, long masterSystemTime)` Updates the location of the specified region to be the specified server.
`static void`	`updateRegionLocation(Connection connection, RegionInfo 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.
`static void`	`updateTableState(Connection conn, TableName tableName, TableState.State actual)` Updates state in META
`private static void`	`updateTableState(Connection connection, TableState state)` Update state of the table in meta.

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.slf4j.Logger LOG
```
- METALOG
```
private static final org.slf4j.Logger METALOG
```
- REPLICATION_PARENT_QUALIFIER
```
public static final byte[] REPLICATION_PARENT_QUALIFIER
```
- ESCAPE_BYTE
```
private static final byte ESCAPE_BYTE
```
  See Also:
  
  Constant Field Values
- SEPARATED_BYTE
```
private static final byte SEPARATED_BYTE
```
  See Also:
  
  Constant Field Values
- META_REPLICA_ID_DELIMITER
```
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

allTableRegions
```
@Deprecated
public static NavigableMap<RegionInfo,ServerName> allTableRegions(Connection connection,
                                                                              TableName tableName)
                                                                       throws IOException
```
Deprecated. use getTableRegionsAndLocations(org.apache.hadoop.hbase.client.Connection, org.apache.hadoop.hbase.TableName), region can have multiple locations

Lists all of the table regions currently in META. Deprecated, keep there until some test use this.

Parameters:

connection - what we will use

tableName - table to list

Returns:

Map of all user-space regions to servers

Throws:

IOException

fullScanRegions

public static void fullScanRegions(Connection connection,
                                   MetaTableAccessor.Visitor visitor)
                            throws IOException

Performs a full scan of hbase:meta for regions.

Parameters:: connection - connection we're using; visitor - Visitor invoked against each row in regions family.
Throws:: IOException

fullScanRegions

public static List<Result> fullScanRegions(Connection connection)
                                    throws IOException

Performs a full scan of hbase:meta for regions.

Parameters:: connection - connection we're using
Throws:: IOException

fullScanTables

public static void fullScanTables(Connection connection,
                                  MetaTableAccessor.Visitor visitor)
                           throws IOException

Performs a full scan of hbase:meta for tables.

Parameters:: connection - connection we're using; visitor - Visitor invoked against each row in tables family.
Throws:: IOException

fullScan

private static List<Result> fullScan(Connection connection,
                                     MetaTableAccessor.QueryType type)
                              throws IOException

Performs a full scan of hbase:meta.

Parameters:: connection - connection we're using; type - scanned part of meta
Returns:: List of Result
Throws:: IOException

getMetaHTable
```
public 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<RegionInfo,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 RegionInfo 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,
                                                RegionInfo 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(RegionInfo regionInfo)

Returns the row key to use for this regionInfo

parseRegionInfoFromRegionName
```
public static RegionInfo 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

scanByRegionEncodedName
```
public static Result scanByRegionEncodedName(Connection connection,
                                             String regionEncodedName)
                                      throws IOException
```
Scans META table for a row whose key contains the specified regionEncodedName, returning a single related Result instance if any row is found, null otherwise.

Parameters:

connection - the connection to query META table.

regionEncodedName - the region encoded name to look for at META.

Returns:

Result instance with the row related info in META, null otherwise.

Throws:

IOException - if any errors occur while querying META.

getMergeRegions

@Nullable
public static List<RegionInfo> getMergeRegions(Connection connection,
                                                         byte[] regionName)
                                                  throws IOException

Returns:: Return all regioninfos listed in the 'info:merge*' columns of the regionName row.
Throws:: IOException

getMergeRegions
```
@Nullable
public static List<RegionInfo> getMergeRegions(Cell[] cells)
```
Returns:

Deserialized regioninfo values taken from column values that match the regex 'info:merge.*' in array of cells.

hasMergeRegions
```
public static boolean hasMergeRegions(Cell[] cells)
```
Returns:

True if any merge regions present in cells; i.e. the column in cell matches the regex 'info:merge.*'.

isMergeQualifierPrefix
```
private static boolean isMergeQualifierPrefix(Cell cell)
```
Returns:

True if the column in cell matches the regex 'info:merge.*'.

getMergeRegionsRaw

@Nullable
private static Cell[] getMergeRegionsRaw(Connection connection,
                                                   byte[] regionName)
                                            throws IOException

Returns:: Array of Cells made from all columns on the regionName row that match the regex 'info:merge.*'.
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

getAllRegions
```
public static List<RegionInfo> getAllRegions(Connection connection,
                                             boolean excludeOfflinedSplitParents)
                                      throws IOException
```
Lists all of the regions currently in META.

Parameters:

connection - to connect with

excludeOfflinedSplitParents - False if we are to include offlined/splitparents regions, true and we'll leave out offlined regions from returned list

Returns:

List of all user-space regions.

Throws:

IOException

getTableRegions
```
public static List<RegionInfo> getTableRegions(Connection connection,
                                               TableName tableName)
                                        throws IOException
```
Gets all of the regions of the specified table. Do not use this method to get meta table regions, use methods in MetaTableLocator instead.

Parameters:

connection - connection we're using

tableName - table we're looking for

Returns:

Ordered list of RegionInfo.

Throws:

IOException

getTableRegions
```
public static List<RegionInfo> getTableRegions(Connection connection,
                                               TableName tableName,
                                               boolean excludeOfflinedSplitParents)
                                        throws IOException
```
Gets all of the regions of the specified table. Do not use this method to get meta table regions, use methods in MetaTableLocator instead.

Parameters:

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 RegionInfo.

Throws:

IOException

getListOfRegionInfos

private static List<RegionInfo> getListOfRegionInfos(List<Pair<RegionInfo,ServerName>> pairs)

getTableStartRowForMeta

public static byte[] getTableStartRowForMeta(TableName tableName,
                                             MetaTableAccessor.QueryType type)

Parameters:: tableName - table we're working with
Returns:: start row for scanning META according to query type

getTableStopRowForMeta

public static byte[] getTableStopRowForMeta(TableName tableName,
                                            MetaTableAccessor.QueryType type)

Parameters:: tableName - table we're working with
Returns:: stop row for scanning META according to query type

getScanForTableName
```
@Deprecated
public static Scan getScanForTableName(Connection connection,
                                                   TableName tableName)
```
Deprecated.

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

getMetaScan

private static Scan getMetaScan(Connection connection,
                                int rowUpperLimit)

getTableRegionsAndLocations

public static List<Pair<RegionInfo,ServerName>> getTableRegionsAndLocations(Connection connection,
                                                                            TableName tableName)
                                                                     throws IOException

Do not use this method to get meta table regions, use methods in MetaTableLocator instead.

Parameters:: 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<RegionInfo,ServerName>> getTableRegionsAndLocations(Connection connection,
                                                                            @Nullable
                                                                            TableName tableName,
                                                                            boolean excludeOfflinedSplitParents)
                                                                     throws IOException

Do not use this method to get meta table regions, use methods in MetaTableLocator instead.

Parameters:: connection - connection we're using; tableName - table to work with, can be null for getting all regions; excludeOfflinedSplitParents - don't return split parents
Returns:: Return list of regioninfos and server addresses.
Throws:: IOException

getServerUserRegions

public static NavigableMap<RegionInfo,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

scanMetaForTableRegions

public static void scanMetaForTableRegions(Connection connection,
                                           MetaTableAccessor.Visitor visitor,
                                           TableName tableName)
                                    throws IOException

Throws:: IOException

scanMeta

private static void scanMeta(Connection connection,
                             TableName table,
                             MetaTableAccessor.QueryType type,
                             int maxRows,
                             MetaTableAccessor.Visitor visitor)
                      throws IOException

Throws:: IOException

scanMeta

private static void scanMeta(Connection connection,
                             @Nullable
                             byte[] startRow,
                             @Nullable
                             byte[] stopRow,
                             MetaTableAccessor.QueryType type,
                             MetaTableAccessor.Visitor visitor)
                      throws IOException

Throws:: IOException

scanMeta

public static void scanMeta(Connection connection,
                            MetaTableAccessor.Visitor visitor,
                            TableName tableName,
                            byte[] row,
                            int rowLimit)
                     throws IOException

Performs a scan of META table for given table starting from given row.

Parameters:: connection - connection we're using; visitor - visitor to call; tableName - table withing we scan; row - start scan from this row; rowLimit - max number of rows to return
Throws:: IOException

scanMeta

static void scanMeta(Connection connection,
                     @Nullable
                     byte[] startRow,
                     @Nullable
                     byte[] stopRow,
                     MetaTableAccessor.QueryType type,
                     int maxRows,
                     MetaTableAccessor.Visitor visitor)
              throws IOException

Performs a scan of META table.

Parameters:: connection - connection we're using; startRow - Where to start the scan. Pass null if want to begin scan at first row.; stopRow - Where to stop the scan. Pass null if want to scan all rows from the start one; type - scanned part of meta; maxRows - maximum rows to return; visitor - Visitor invoked against each row.
Throws:: IOException

getClosestRegionInfo

@NonNull
private static RegionInfo getClosestRegionInfo(Connection connection,
                                                        @NonNull
                                                        TableName tableName,
                                                        @NonNull
                                                        byte[] row)
                                                 throws IOException

Returns:: Get closest metatable region row to passed row
Throws:: IOException

getCatalogFamily
```
public static byte[] getCatalogFamily()
```
Returns the column family used for meta columns.

Returns:

HConstants.CATALOG_FAMILY.

getTableFamily
```
private static byte[] getTableFamily()
```
Returns the column family used for table columns.

Returns:

HConstants.TABLE_FAMILY.

getRegionInfoColumn
```
public static byte[] getRegionInfoColumn()
```
Returns the column qualifier for serialized region info

Returns:

HConstants.REGIONINFO_QUALIFIER

getTableStateColumn
```
private static byte[] getTableStateColumn()
```
Returns the column qualifier for serialized table state

Returns:

HConstants.TABLE_STATE_QUALIFIER

getRegionStateColumn
```
private static byte[] getRegionStateColumn()
```
Returns the column qualifier for serialized region state

Returns:

HConstants.TABLE_STATE_QUALIFIER

getRegionStateColumn
```
static byte[] getRegionStateColumn(int replicaId)
```
Returns the column qualifier for serialized region state

Parameters:

replicaId - the replicaId of the region

Returns:

a byte[] for state qualifier

getServerNameColumn
```
static byte[] getServerNameColumn(int replicaId)
```
Returns the column qualifier for serialized region state

Parameters:

replicaId - the replicaId of the region

Returns:

a byte[] for sn column 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

@Nullable
 @InterfaceAudience.Private
public 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.

getDaughterRegions
```
public static PairOfSameType<RegionInfo> 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:

pair of RegionInfo or PairOfSameType(null, null) if region is not a split parent

getRegionLocations
```
@Nullable
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,
                                                 RegionInfo 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

getRegionInfo
```
public static RegionInfo getRegionInfo(Result data)
```
Returns RegionInfo 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:

RegionInfo or null

getRegionInfo
```
@Nullable
public static RegionInfo getRegionInfo(Result r,
                                                 byte[] qualifier)
```
Returns the RegionInfo 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 RegionInfo instance or null.

getTableState

@Nullable
public static TableState getTableState(Connection conn,
                                                 TableName tableName)
                                          throws IOException

Fetch table state for given table from META table

Parameters:: conn - connection to use; tableName - table to fetch state for
Throws:: IOException

getTableStates

public static Map<TableName,TableState> getTableStates(Connection conn)
                                                throws IOException

Fetch table states from META table

Parameters:: conn - connection to use
Returns:: map {tableName -> state}
Throws:: IOException

updateTableState

public static void updateTableState(Connection conn,
                                    TableName tableName,
                                    TableState.State actual)
                             throws IOException

Updates state in META

Parameters:: conn - connection to use; tableName - table to look for
Throws:: IOException

getTableState
```
@Nullable
public static TableState getTableState(Result r)
                                          throws IOException
```
Decode table state from META Result. Should contain cell from HConstants.TABLE_FAMILY

Returns:

null if not found

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(RegionInfo regionInfo,
                                        long ts)
                                 throws IOException

Generates and returns a Put containing the region into for the catalog table

Throws:: IOException

makeDeleteFromRegionInfo

private static Delete makeDeleteFromRegionInfo(RegionInfo regionInfo,
                                               long ts)

Generates and returns a Delete containing the region info for the catalog table

addDaughtersToPut

private static Put addDaughtersToPut(Put put,
                                     RegionInfo splitA,
                                     RegionInfo splitB)
                              throws IOException

Adds split daughters to the Put

Throws:: IOException

putToMetaTable

private 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; 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

private 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

private 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

addRegionStateToPut

private static void addRegionStateToPut(Put put,
                                        RegionState.State state)
                                 throws IOException

Throws:: IOException

addSplitsToParent
```
public static void addSplitsToParent(Connection connection,
                                     RegionInfo regionInfo,
                                     RegionInfo splitA,
                                     RegionInfo splitB)
                              throws IOException
```
Adds daughter region infos to hbase:meta row for the specified region. 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, RegionInfo, RegionInfo, RegionInfo, ServerName,int) if you want to do that.

Parameters:

connection - connection we're using

regionInfo - RegionInfo of parent region

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,
                                   RegionInfo regionInfo)
                            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, RegionInfo, RegionInfo, RegionInfo, ServerName, int) if you want to do that.

Parameters:

connection - connection we're using

regionInfo - region information

Throws:

IOException - if problem connecting or updating meta

addRegionsToMeta

public static void addRegionsToMeta(Connection connection,
                                    List<RegionInfo> regionInfos,
                                    int regionReplication)
                             throws IOException

Adds a hbase:meta row for each of the specified new regions. Initial state for new regions is CLOSED.

Parameters:: connection - connection we're using; regionInfos - region information list
Throws:: IOException - if problem connecting or updating meta

addRegionsToMeta

private static void addRegionsToMeta(Connection connection,
                                     List<RegionInfo> regionInfos,
                                     int regionReplication,
                                     long ts)
                              throws IOException

Adds a hbase:meta row for each of the specified new regions. Initial state for new regions is CLOSED.

Parameters:: connection - connection we're using; regionInfos - region information list; ts - desired timestamp
Throws:: IOException - if problem connecting or updating meta

addMergeRegions

static Put addMergeRegions(Put put,
                           Collection<RegionInfo> mergeRegions)
                    throws IOException

Throws:: IOException

mergeRegions

public static void mergeRegions(Connection connection,
                                RegionInfo mergedRegion,
                                RegionInfo[] parents,
                                ServerName sn,
                                int regionReplication)
                         throws IOException

Merge regions into one in an atomic operation. Deletes the merging regions in hbase:meta and adds the merged region.

Parameters:: connection - connection we're using; mergedRegion - the merged region; sn - the location of the region
Throws:: IOException

splitRegion

public static void splitRegion(Connection connection,
                               RegionInfo parent,
                               RegionInfo splitA,
                               RegionInfo 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 B; sn - the location of the region
Throws:: IOException

updateTableState

private static void updateTableState(Connection connection,
                                     TableState state)
                              throws IOException

Update state of the table in meta.

Parameters:: connection - what we use for update; state - new state
Throws:: IOException

makePutFromTableState

public static Put makePutFromTableState(TableState state,
                                        long ts)

Construct PUT for given state

Parameters:: state - new state

deleteTableState

public static void deleteTableState(Connection connection,
                                    TableName table)
                             throws IOException

Remove state for table from meta

Parameters:: connection - to use for deletion; table - to delete state for
Throws:: IOException

multiMutate

private static void multiMutate(Connection connection,
                                Table table,
                                byte[] row,
                                Mutation... mutations)
                         throws IOException

Throws:: IOException

multiMutate

public static void multiMutate(Connection connection,
                               Table table,
                               byte[] row,
                               List<Mutation> mutations)
                        throws IOException

Performs an atomic multi-mutate operation against the given table.

Throws:: IOException

updateRegionLocation
```
public static void updateRegionLocation(Connection connection,
                                        RegionInfo 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

Throws:

IOException

updateLocation
```
private static void updateLocation(Connection connection,
                                   RegionInfo 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

Throws:

IOException - In particular could throw ConnectException if the server is down on other end.

deleteRegionInfo

public static void deleteRegionInfo(Connection connection,
                                    RegionInfo regionInfo)
                             throws IOException

Deletes the specified region from META.

Parameters:: connection - connection we're using; regionInfo - region to be deleted from META
Throws:: IOException

deleteRegionInfos

public static void deleteRegionInfos(Connection connection,
                                     List<RegionInfo> 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

deleteRegionInfos

private static void deleteRegionInfos(Connection connection,
                                      List<RegionInfo> 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
Throws:: IOException

overwriteRegions

public static void overwriteRegions(Connection connection,
                                    List<RegionInfo> regionInfos,
                                    int regionReplication)
                             throws IOException

Overwrites the specified regions from hbase:meta. Deletes old rows for the given regions and adds new ones. Regions added back have state CLOSED.

Parameters:: connection - connection we're using; regionInfos - list of regions to be added to META
Throws:: IOException

deleteMergeQualifiers

public static void deleteMergeQualifiers(Connection connection,
                                         RegionInfo mergeRegion)
                                  throws IOException

Deletes merge qualifiers for the specified merge region.

Parameters:: connection - connection we're using; mergeRegion - the merged region
Throws:: IOException

addRegionInfo

public static Put addRegionInfo(Put p,
                                RegionInfo hri)
                         throws IOException

Throws:: IOException

addLocation

public static Put addLocation(Put p,
                              ServerName sn,
                              long openSeqNum,
                              int replicaId)
                       throws IOException

Throws:: IOException

addEmptyLocation

private static Put addEmptyLocation(Put p,
                                    int replicaId)
                             throws IOException

Throws:: IOException

debugLogMutations

private static void debugLogMutations(List<? extends Mutation> mutations)
                               throws IOException

Throws:: IOException

debugLogMutation

private static void debugLogMutation(Mutation p)
                              throws IOException

Throws:: IOException

addSequenceNum

private static Put addSequenceNum(Put p,
                                  long openSeqNum,
                                  int replicaId)
                           throws IOException

Throws:: IOException

Class MetaTableAccessor

Meta layout

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LOG

METALOG

REPLICATION_PARENT_QUALIFIER

ESCAPE_BYTE

SEPARATED_BYTE

META_REPLICA_ID_DELIMITER

SERVER_COLUMN_PATTERN

Constructor Detail

MetaTableAccessor

Method Detail

allTableRegions

fullScanRegions

fullScanRegions

fullScanTables

fullScan

getMetaHTable

get

getRegion

getRegionLocation

getRegionLocation

getMetaKeyForRegion

parseRegionInfoFromRegionName

getRegionResult

scanByRegionEncodedName

getMergeRegions

getMergeRegions

hasMergeRegions

isMergeQualifierPrefix

getMergeRegionsRaw

tableExists

getAllRegions

getTableRegions

getTableRegions

getListOfRegionInfos

getTableStartRowForMeta

getTableStopRowForMeta

getScanForTableName

getMetaScan

getTableRegionsAndLocations

getTableRegionsAndLocations

getServerUserRegions

fullScanMetaAndPrint

scanMetaForTableRegions

scanMeta

scanMeta

scanMeta

scanMeta

getClosestRegionInfo

getCatalogFamily

getTableFamily

getRegionInfoColumn

getTableStateColumn

getRegionStateColumn

getRegionStateColumn

getServerNameColumn

getServerColumn

getStartCodeColumn

getSeqNumColumn

parseReplicaIdFromServerColumn

getServerName

getSeqNumDuringOpen

getDaughterRegions

getRegionLocations

getRegionLocation

getRegionInfo

getRegionInfo

getTableState

getTableStates

updateTableState

getTableState

getRegionCount

getRegionCount