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.

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

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	addEmptyLocation(Put p, int replicaId)
static Put	addLocation(Put p, ServerName sn, long openSeqNum, long time, 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	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 hbase:meta row for the specified new region.
static Put	addSequenceNum(Put p, long openSeqNum, long time, int replicaId)
static void	addSpiltsToParent(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	deleteFromMetaTable(Connection connection, List<Delete> deletes) Delete the passed deletes from the hbase:meta table.
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 Map<String,List<Long>>	getAllBarriers(Connection connection) Get all barriers in all regions.
static List<RegionInfo>	getAllRegions(Connection connection, boolean excludeOfflinedSplitParents) Lists all of the regions currently in META.
protected static byte[]	getCatalogFamily() Returns the column family used for meta columns.
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.
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 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.
protected static byte[]	getRegionInfoColumn() Returns the column qualifier for serialized region info
static HRegionLocation	getRegionLocation(Connection connection, byte[] regionName) Returns the HRegionLocation from meta for the given region
static HRegionLocation	getRegionLocation(Connection connection, 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
protected static byte[]	getRegionStateColumn() Returns the column qualifier for serialized region state
static List<Long>	getReplicationBarriers(Connection connection, byte[] encodedRegionName) Get replication barriers for all peers in a region.
static Map<String,Long>	getReplicationPositionForAllPeer(Connection connection, byte[] encodedRegionName) Get replication positions for all peers in a region.
static long	getReplicationPositionForOnePeer(Connection connection, byte[] encodedRegionName, String peerId) Get replication position for a peer in a region.
static Scan	getScanForTableName(Connection connection, TableName tableName) Deprecated.
static byte[]	getSeqNumColumn(int replicaId) Returns the column qualifier for seqNum column for replicaId
static String	getSerialReplicationDaughterRegion(Connection connection, byte[] encodedName) Get daughter region(s) for a region, only used in serial replication.
static String	getSerialReplicationParentRegion(Connection connection, byte[] encodedName) Get parent region(s) for a region, only used in serial replication.
static String	getSerialReplicationTableName(Connection connection, byte[] encodedName) Get the table name for a region, only used in serial replication.
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
protected 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.
protected 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 Put	makeBarrierPut(byte[] encodedRegionName, long seq, byte[] tableName)
static Put	makeDaughterPut(byte[] encodedRegionName, byte[] value)
static Delete	makeDeleteFromRegionInfo(RegionInfo regionInfo) Generates and returns a Delete containing the region info for the catalog table
static Delete	makeDeleteFromRegionInfo(RegionInfo regionInfo, long ts) Generates and returns a Delete containing the region info for the catalog table
static Put	makeParentPut(byte[] encodedRegionName, byte[] value)
static Put	makePutFromRegionInfo(RegionInfo regionInfo) Generates and returns a Put containing the region into 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) Construct PUT for given state
static void	mergeRegions(Connection connection, RegionInfo mergedRegion, RegionInfo regionA, RegionInfo regionB, ServerName sn, int regionReplication, long masterSystemTime, boolean saveBarrier) Merge the two 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.
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	putToMetaTable(Connection connection, Put... puts) Put the passed puts 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, RegionInfo splitA, RegionInfo splitB, ServerName sn, int regionReplication, boolean saveBarrier) 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	updateReplicationPositions(Connection connection, String peerId, Map<String,Long> positions) Updates the progress of pushing entries to peer cluster.
static void	updateTableState(Connection conn, TableName tableName, TableState.State actual) Updates state in META
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

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

getClosestRegionInfo

@NonNull
public 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

protected static byte[] getCatalogFamily()

Returns the column family used for meta columns.

Returns:

HConstants.CATALOG_FAMILY.

getTableFamily

protected static byte[] getTableFamily()

Returns the column family used for table columns.

Returns:

HConstants.TABLE_FAMILY.

getRegionInfoColumn

protected static byte[] getRegionInfoColumn()

Returns the column qualifier for serialized region info

Returns:

HConstants.REGIONINFO_QUALIFIER

getTableStateColumn

protected static byte[] getTableStateColumn()

Returns the column qualifier for serialized table state

Returns:

HConstants.TABLE_STATE_QUALIFIER

getRegionStateColumn

protected static byte[] getRegionStateColumn()

Returns the column qualifier for serialized region state

Returns:

HConstants.TABLE_STATE_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

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)
                                 throws IOException

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

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

public static Delete makeDeleteFromRegionInfo(RegionInfo regionInfo)

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

makeDeleteFromRegionInfo

public static Delete makeDeleteFromRegionInfo(RegionInfo regionInfo,
                                              long ts)

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

makeBarrierPut

public static Put makeBarrierPut(byte[] encodedRegionName,
                                 long seq,
                                 byte[] tableName)
                          throws IOException

Throws:

IOException

makeDaughterPut

public static Put makeDaughterPut(byte[] encodedRegionName,
                                  byte[] value)
                           throws IOException

Throws:

IOException

makeParentPut

public static Put makeParentPut(byte[] encodedRegionName,
                                byte[] value)
                         throws IOException

Throws:

IOException

addDaughtersToPut

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

Adds split daughters to the Put

Throws:

IOException

putToMetaTable

public static void putToMetaTable(Connection connection,
                                  Put... puts)
                           throws IOException

Put the passed puts to the hbase:meta table. Non-atomic for multi puts.

Parameters:

connection - connection we're using

puts - Put to add to hbase:meta

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

public static void deleteFromMetaTable(Connection connection,
                                       List<Delete> deletes)
                                throws IOException

Delete the passed deletes from the hbase:meta table.

Parameters:

connection - connection we're using

deletes - Deletes to add to hbase:meta This list should support #remove.

Throws:

IOException

removeRegionReplicasFromMeta

public static void removeRegionReplicasFromMeta(Set<byte[]> metaRows,
                                                int replicaIndexToDeleteFrom,
                                                int numReplicasToRemove,
                                                Connection connection)
                                         throws IOException

Deletes some replica columns corresponding to replicas for the passed rows

Parameters:

metaRows - rows in hbase:meta

replicaIndexToDeleteFrom - the replica ID we would start deleting from

numReplicasToRemove - how many replicas to remove

connection - connection we're using to access meta table

Throws:

IOException

mutateMetaTable

public static void mutateMetaTable(Connection connection,
                                   List<Mutation> mutations)
                            throws IOException

Execute the passed mutations against hbase:meta table.

Parameters:

connection - connection we're using

mutations - Puts and Deletes to execute on hbase:meta

Throws:

IOException

addSpiltsToParent

public static void addSpiltsToParent(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,boolean) 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 hbase:meta row for the specified new region. Initial state of new region is CLOSED.

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

public 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

regionReplication -

ts - desired timestamp

Throws:

IOException - if problem connecting or updating meta

mergeRegions

public static void mergeRegions(Connection connection,
                                RegionInfo mergedRegion,
                                RegionInfo regionA,
                                RegionInfo regionB,
                                ServerName sn,
                                int regionReplication,
                                long masterSystemTime,
                                boolean saveBarrier)
                         throws IOException

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

Parameters:

connection - connection we're using

mergedRegion - the merged region

regionA -

regionB -

sn - the location of the region

masterSystemTime -

saveBarrier - true if need save replication barrier in meta, used for serial replication

Throws:

IOException

splitRegion

public static void splitRegion(Connection connection,
                               RegionInfo parent,
                               RegionInfo splitA,
                               RegionInfo splitB,
                               ServerName sn,
                               int regionReplication,
                               boolean saveBarrier)
                        throws IOException

Splits the region into two in an atomic operation. Offlines the parent region with the information that it is split into two, and also adds the daughter regions. Does not add the location information to the daughter regions since they are not open yet.

Parameters:

connection - connection we're using

parent - the parent region which is split

splitA - Split daughter region A

splitB - Split daughter region A

sn - the location of the region

saveBarrier - true if need save replication barrier in meta, used for serial replication

Throws:

IOException

updateTableState

public 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)

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

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 or -1

Throws:

IOException

updateReplicationPositions

public static void updateReplicationPositions(Connection connection,
                                              String peerId,
                                              Map<String,Long> positions)
                                       throws IOException

Updates the progress of pushing entries to peer cluster. Skip entry if value is -1.

Parameters:

connection - connection we're using

peerId - the peerId to push

positions - map that saving positions for each region

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 -

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,
                              long time,
                              int replicaId)
                       throws IOException

Throws:

IOException

addEmptyLocation

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

Throws:

IOException

addSequenceNum

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

Throws:

IOException

getReplicationPositionForOnePeer

public static long getReplicationPositionForOnePeer(Connection connection,
                                                    byte[] encodedRegionName,
                                                    String peerId)
                                             throws IOException

Get replication position for a peer in a region.

Parameters:

connection - connection we're using

Returns:

the position of this peer, -1 if no position in meta.

Throws:

IOException

getReplicationPositionForAllPeer

public static Map<String,Long> getReplicationPositionForAllPeer(Connection connection,
                                                                byte[] encodedRegionName)
                                                         throws IOException

Get replication positions for all peers in a region.

Parameters:

connection - connection we're using

encodedRegionName - region's encoded name

Returns:

the map of positions for each peer

Throws:

IOException

getReplicationBarriers

public static List<Long> getReplicationBarriers(Connection connection,
                                                byte[] encodedRegionName)
                                         throws IOException

Get replication barriers for all peers in a region.

Parameters:

encodedRegionName - region's encoded name

Returns:

a list of barrier sequence numbers.

Throws:

IOException

getAllBarriers

public static Map<String,List<Long>> getAllBarriers(Connection connection)
                                             throws IOException

Get all barriers in all regions.

Returns:

a map of barrier lists in all regions

Throws:

IOException

getSerialReplicationDaughterRegion

public static String getSerialReplicationDaughterRegion(Connection connection,
                                                        byte[] encodedName)
                                                 throws IOException

Get daughter region(s) for a region, only used in serial replication.

Parameters:

connection - connection we're using

encodedName - region's encoded name

Throws:

IOException

getSerialReplicationParentRegion

public static String getSerialReplicationParentRegion(Connection connection,
                                                      byte[] encodedName)
                                               throws IOException

Get parent region(s) for a region, only used in serial replication.

Parameters:

connection - connection we're using

encodedName - region's encoded name

Throws:

IOException

getSerialReplicationTableName

public static String getSerialReplicationTableName(Connection connection,
                                                   byte[] encodedName)
                                            throws IOException

Get the table name for a region, only used in serial replication.

Parameters:

connection - connection we're using

encodedName - region's encoded name

Throws:

IOException