org.apache.hadoop.hbase

Class MetaTableAccessor

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.

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 (as of 0.98 + HBASE-10070) is like:

 For each table there is single row in column family 'table' formatted:
 <tableName> including namespace and columns are:
 table: state             => contains table state

 For each table range, there is a single row, formatted like:
 <tableName>,<startKey>,<regionId>,<encodedRegionName>.
 This row corresponds to the 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:mergeA             => contains a serialized HRI for the first parent region if the
                             region is the result of a merge
 info:mergeB             => contains a serialized HRI for the second parent region if the
                             region is the result of a merge
 

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.
static class	MetaTableAccessor.DefaultVisitorBase A Visitor that skips offline regions and split parents
static class	MetaTableAccessor.QueryType
static class	MetaTableAccessor.ReplicationBarrierResult
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
protected static char	META_REPLICA_ID_DELIMITER The delimiter for meta columns for replicaIds > 0
static byte[]	REPLICATION_PARENT_QUALIFIER

Constructor Summary

Constructors

Constructor and Description
MetaTableAccessor()

Method Summary

Modifier and Type	Method and Description
static Put	addDaughtersToPut(Put put, RegionInfo splitA, RegionInfo splitB) Adds split daughters to the Put
static Put	addLocation(Put p, ServerName sn, long openSeqNum, int replicaId)
static Put	addRegionInfo(Put p, RegionInfo hri)
static void	addRegionsToMeta(Connection connection, List<RegionInfo> regionInfos, int regionReplication) 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.
static void	addReplicationBarrier(Put put, long openSeqNum)
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
static void	deleteMergeQualifiers(Connection connection, RegionInfo mergedRegion) Deletes merge qualifiers for the specified merged region.
static void	deleteRegion(Connection connection, RegionInfo regionInfo) Deletes the specified region from META.
static void	deleteRegions(Connection connection, List<RegionInfo> regionsInfo) Deletes the specified regions from META.
static void	deleteRegions(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
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.
static List<RegionInfo>	getAllRegions(Connection connection, boolean excludeOfflinedSplitParents) Lists all of the regions currently in META.
static PairOfSameType<RegionInfo>	getDaughterRegions(Result data) Returns the daughter regions by reading the corresponding columns of the catalog table Result.
static PairOfSameType<RegionInfo>	getMergeRegions(Result data) Returns the merge regions by reading the corresponding columns of the catalog table Result.
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
static byte[]	getParentsBytes(List<RegionInfo> parents)
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 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
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<RegionInfo,RegionInfo>	getRegionsFromMergeQualifier(Connection connection, byte[] regionName) Get regions from the merge qualifier of the specified merged region
static long[]	getReplicationBarrier(Connection conn, byte[] regionName)
static MetaTableAccessor.ReplicationBarrierResult	getReplicationBarrierResult(Connection conn, TableName tableName, byte[] row, byte[] encodedRegionName)
static long[]	getReplicationBarriers(Result result)
static Scan	getScanForTableName(Connection connection, TableName tableName) Deprecated.
static byte[]	getSeqNumColumn(int replicaId) Returns the column qualifier for seqNum column for replicaId
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.
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
static List<Pair<String,Long>>	getTableEncodedRegionNameAndLastBarrier(Connection conn, TableName tableName)
static List<String>	getTableEncodedRegionNamesForSerialReplication(Connection conn, TableName tableName)
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.
static Map<TableName,TableState>	getTableStates(Connection conn) Fetch table states from META table
static byte[]	getTableStopRowForMeta(TableName tableName, MetaTableAccessor.QueryType type)
static Put	makePutForReplicationBarrier(RegionInfo regionInfo, long openSeqNum, long ts)
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 regionA, long regionAOpenSeqNum, RegionInfo regionB, long regionBOpenSeqNum, ServerName sn, int regionReplication) Merge the two regions into one in an atomic operation.
static void	mutateMetaTable(Connection connection, List<Mutation> mutations) Execute the passed mutations against hbase:meta table.
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.
static void	putsToMetaTable(Connection connection, List<Put> ps) Put the passed ps 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	scanMeta(Connection connection, byte[] startRow, byte[] stopRow, MetaTableAccessor.QueryType type, int maxRows, MetaTableAccessor.Visitor visitor) Performs a scan of META table.
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.
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, long parentOpenSeqNum, 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.
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

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

REPLICATION_PARENT_QUALIFIER

public static final byte[] REPLICATION_PARENT_QUALIFIER

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

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

public 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

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

getRegionsFromMergeQualifier

@Nullable
public static Pair<RegionInfo,RegionInfo> 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

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

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

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

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

Throws:

IOException

scanMeta

public 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

public 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

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

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.

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.

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

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:

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

getMergeRegions

public static PairOfSameType<RegionInfo> 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 RegionInfo or PairOfSameType(null, null) if the region is not a split parent

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

Returns:

state

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

Parameters:

r - result

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

addDaughtersToPut

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

Adds split daughters to the Put

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

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

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, long, 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, long, 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

mergeRegions

public static void mergeRegions(Connection connection,
                                RegionInfo mergedRegion,
                                RegionInfo regionA,
                                long regionAOpenSeqNum,
                                RegionInfo regionB,
                                long regionBOpenSeqNum,
                                ServerName sn,
                                int regionReplication)
                         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 - merge parent region A

regionAOpenSeqNum - the next open sequence id for region A, used by serial replication. -1 if not necessary.

regionB - merge parent region B

regionBOpenSeqNum - the next open sequence id for region B, used by serial replication. -1 if not necessary.

sn - the location of the region

Throws:

IOException

splitRegion

public static void splitRegion(Connection connection,
                               RegionInfo parent,
                               long parentOpenSeqNum,
                               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

parentOpenSeqNum - the next open sequence id for parent region, used by serial replication. -1 if not necessary.

splitA - Split daughter region A

splitB - Split daughter region B

sn - the location of the region

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

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

deleteRegion

public static void deleteRegion(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

deleteRegions

public static void deleteRegions(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

deleteRegions

public static void deleteRegions(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 mergedRegion)
                                  throws IOException

Deletes merge qualifiers for the specified merged region.

Parameters:

connection - connection we're using

mergedRegion - 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

getParentsBytes

public static byte[] getParentsBytes(List<RegionInfo> parents)

makePutForReplicationBarrier

public static Put makePutForReplicationBarrier(RegionInfo regionInfo,
                                               long openSeqNum,
                                               long ts)
                                        throws IOException

Throws:

IOException

addReplicationBarrier

public static void addReplicationBarrier(Put put,
                                         long openSeqNum)
                                  throws IOException

Throws:

IOException

getReplicationBarriers

public static long[] getReplicationBarriers(Result result)

getReplicationBarrierResult

public static MetaTableAccessor.ReplicationBarrierResult getReplicationBarrierResult(Connection conn,
                                                                                     TableName tableName,
                                                                                     byte[] row,
                                                                                     byte[] encodedRegionName)
                                                                              throws IOException

Throws:

IOException

getReplicationBarrier

public static long[] getReplicationBarrier(Connection conn,
                                           byte[] regionName)
                                    throws IOException

Throws:

IOException

getTableEncodedRegionNameAndLastBarrier

public static List<Pair<String,Long>> getTableEncodedRegionNameAndLastBarrier(Connection conn,
                                                                              TableName tableName)
                                                                       throws IOException

Throws:

IOException

getTableEncodedRegionNamesForSerialReplication

public static List<String> getTableEncodedRegionNamesForSerialReplication(Connection conn,
                                                                          TableName tableName)
                                                                   throws IOException

Throws:

IOException