TableName (Apache HBase 2.5.0 API)

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

All Implemented Interfaces:

Comparable<TableName>
```
@InterfaceAudience.Public
public final class TableName
extends Object
implements Comparable<TableName>
```
Immutable POJO class for representing a table name. Which is of the form: <table namespace>:<table qualifier> Two special namespaces: 1. hbase - system namespace, used to contain hbase internal tables 2. default - tables with no explicit specified namespace will automatically fall into this namespace. ie a) foo:bar, means namespace=foo and qualifier=bar b) bar, means namespace=default and qualifier=bar c) default:bar, means namespace=default and qualifier=bar
Internally, in this class, we cache the instances to limit the number of objects and make the "equals" faster. We try to minimize the number of objects created of the number of array copy to check if we already have an instance of this TableName. The code is not optimize for a new instance creation but is optimized to check for existence.

Field Summary

Fields
Modifier and Type	Field and Description
`static String`	`DISALLOWED_TABLE_NAME` One globally disallowed name
`static TableName`	`META_TABLE_NAME` The hbase:meta table's name.
`static char`	`NAMESPACE_DELIM` Namespace delimiter
`static TableName`	`NAMESPACE_TABLE_NAME` The Namespace table's name.
`static String`	`OLD_META_STR`
`static TableName`	`OLD_META_TABLE_NAME` TableName for old .META.
`static String`	`OLD_ROOT_STR`
`static TableName`	`OLD_ROOT_TABLE_NAME` TableName for old -ROOT- table.
`static String`	`VALID_NAMESPACE_REGEX`
`static String`	`VALID_TABLE_QUALIFIER_REGEX`
`static String`	`VALID_USER_TABLE_REGEX`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`int`	`compareTo(TableName tableName)`
`boolean`	`equals(Object o)`
`byte[]`	`getName()`
`String`	`getNameAsString()`
`byte[]`	`getNamespace()`
`String`	`getNamespaceAsString()`
`String`	`getNameWithNamespaceInclAsString()` Ideally, getNameAsString should contain namespace within it, but if the namespace is default, it just returns the name.
`byte[]`	`getQualifier()`
`String`	`getQualifierAsString()`
`int`	`hashCode()`
`static byte[]`	`isLegalFullyQualifiedTableName(byte[] tableName)` Check passed byte array, "tableName", is legal user-space table name.
`static void`	`isLegalNamespaceName(byte[] namespaceName)`
`static void`	`isLegalNamespaceName(byte[] namespaceName, int start, int end)` Valid namespace characters are alphabetic characters, numbers, and underscores.
`static byte[]`	`isLegalTableQualifierName(byte[] qualifierName)`
`static byte[]`	`isLegalTableQualifierName(byte[] qualifierName, boolean isSnapshot)`
`static void`	`isLegalTableQualifierName(byte[] qualifierName, int start, int end)` Qualifier names can only contain 'word' characters `[\p{IsAlphabetic}\p{Digit}]` or '_', '.' or '-'.
`static void`	`isLegalTableQualifierName(byte[] qualifierName, int start, int end, boolean isSnapshot)`
`static boolean`	`isMetaTableName(TableName tn)` Returns True if `tn` is the hbase:meta table name.
`boolean`	`isSystemTable()`
`byte[]`	`toBytes()` Returns A pointer to TableName as String bytes.
`String`	`toString()`
`static TableName`	`valueOf(byte[] fullName)` Construct a TableName
`static TableName`	`valueOf(byte[] namespace, byte[] qualifier)`
`static TableName`	`valueOf(byte[] fullName, int offset, int length)` Construct a TableName
`static TableName`	`valueOf(ByteBuffer fullname)` Construct a TableName
`static TableName`	`valueOf(ByteBuffer namespace, ByteBuffer qualifier)`
`static TableName`	`valueOf(String name)` Construct a TableName
`static TableName`	`valueOf(String namespaceAsString, String qualifierAsString)`

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

- Field Detail
  - NAMESPACE_DELIM
```
public static final char NAMESPACE_DELIM
```
    Namespace delimiter
    
    See Also:
    
    Constant Field Values
  - VALID_NAMESPACE_REGEX
```
public static final String VALID_NAMESPACE_REGEX
```
    See Also:
    
    Constant Field Values
  - VALID_TABLE_QUALIFIER_REGEX
```
public static final String VALID_TABLE_QUALIFIER_REGEX
```
    See Also:
    
    Constant Field Values
  - VALID_USER_TABLE_REGEX
```
public static final String VALID_USER_TABLE_REGEX
```
    See Also:
    
    Constant Field Values
  - META_TABLE_NAME
```
public static final TableName META_TABLE_NAME
```
    The hbase:meta table's name.
  - NAMESPACE_TABLE_NAME
```
public static final TableName NAMESPACE_TABLE_NAME
```
    The Namespace table's name.
  - OLD_META_STR
```
public static final String OLD_META_STR
```
    See Also:
    
    Constant Field Values
  - OLD_ROOT_STR
```
public static final String OLD_ROOT_STR
```
    See Also:
    
    Constant Field Values
  - DISALLOWED_TABLE_NAME
```
public static final String DISALLOWED_TABLE_NAME
```
    One globally disallowed name
    
    See Also:
    
    Constant Field Values
  - OLD_ROOT_TABLE_NAME
```
public static final TableName OLD_ROOT_TABLE_NAME
```
    TableName for old -ROOT- table. It is used to read/process old WALs which have ROOT edits.
  - OLD_META_TABLE_NAME
```
public static final TableName OLD_META_TABLE_NAME
```
    TableName for old .META. table. Used in testing.
- Method Detail
  - isMetaTableName
```
public static boolean isMetaTableName(TableName tn)
```
    Returns True if tn is the hbase:meta table name.
  - isLegalFullyQualifiedTableName
```
public static byte[] isLegalFullyQualifiedTableName(byte[] tableName)
```
    Check passed byte array, "tableName", is legal user-space table name.
    
    Returns:
    
    Returns passed tableName param
    
    Throws:
    
    IllegalArgumentException - if passed a tableName is null or is made of other than 'word' characters or underscores: i.e. [\p{IsAlphabetic}\p{Digit}.-:]. The ':' is used to delimit the namespace from the table name and can be used for nothing else. Namespace names can only contain 'word' characters [\p{IsAlphabetic}\p{Digit}] or '_' Qualifier names can only contain 'word' characters [\p{IsAlphabetic}\p{Digit}] or '_', '.' or '-'. The name may not start with '.' or '-'. Valid fully qualified table names: foo:bar, namespace=>foo, table=>bar org:foo.bar, namespace=org, table=>foo.bar
  - isLegalTableQualifierName
```
public static byte[] isLegalTableQualifierName(byte[] qualifierName)
```
  - isLegalTableQualifierName
```
public static byte[] isLegalTableQualifierName(byte[] qualifierName,
                                               boolean isSnapshot)
```
  - isLegalTableQualifierName
```
public static void isLegalTableQualifierName(byte[] qualifierName,
                                             int start,
                                             int end)
```
    Qualifier names can only contain 'word' characters [\p{IsAlphabetic}\p{Digit}] or '_', '.' or '-'. The name may not start with '.' or '-'.
    
    Parameters:
    
    qualifierName - byte array containing the qualifier name
    
    start - start index
    
    end - end index (exclusive)
  - isLegalTableQualifierName
```
public static void isLegalTableQualifierName(byte[] qualifierName,
                                             int start,
                                             int end,
                                             boolean isSnapshot)
```
  - isLegalNamespaceName
```
public static void isLegalNamespaceName(byte[] namespaceName)
```
  - isLegalNamespaceName
```
public static void isLegalNamespaceName(byte[] namespaceName,
                                        int start,
                                        int end)
```
    Valid namespace characters are alphabetic characters, numbers, and underscores.
  - getName
```
public byte[] getName()
```
  - getNameAsString
```
public String getNameAsString()
```
  - getNamespace
```
public byte[] getNamespace()
```
  - getNamespaceAsString
```
public String getNamespaceAsString()
```
  - getNameWithNamespaceInclAsString
```
public String getNameWithNamespaceInclAsString()
```
    Ideally, getNameAsString should contain namespace within it, but if the namespace is default, it just returns the name. This method takes care of this corner case.
  - getQualifier
```
public byte[] getQualifier()
```
  - getQualifierAsString
```
public String getQualifierAsString()
```
  - toBytes
```
public byte[] toBytes()
```
    Returns A pointer to TableName as String bytes.
  - isSystemTable
```
public boolean isSystemTable()
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - valueOf
```
public static TableName valueOf(String namespaceAsString,
                                String qualifierAsString)
```
  - valueOf
```
public static TableName valueOf(byte[] fullName)
                         throws IllegalArgumentException
```
    Construct a TableName
    
    Parameters:
    
    fullName - will use the entire byte array
    
    Throws:
    
    IllegalArgumentException - if fullName equals old root or old meta. Some code depends on this. The test is buried in the table creation to save on array comparison when we're creating a standard table object that will be in the cache.
  - valueOf
```
public static TableName valueOf(byte[] fullName,
                                int offset,
                                int length)
                         throws IllegalArgumentException
```
    Construct a TableName
    
    Parameters:
    
    fullName - byte array to look into
    
    offset - within said array
    
    length - within said array
    
    Throws:
    
    IllegalArgumentException - if fullName equals old root or old meta.
  - valueOf
```
public static TableName valueOf(ByteBuffer fullname)
```
    Construct a TableName
    
    Parameters:
    
    fullname - of a table, possibly with a leading namespace and ':' as delimiter.
    
    Throws:
    
    IllegalArgumentException - if fullName equals old root or old meta.
  - valueOf
```
public static TableName valueOf(String name)
```
    Construct a TableName
    
    Throws:
    
    IllegalArgumentException - if fullName equals old root or old meta. Some code depends on this.
  - valueOf
```
public static TableName valueOf(byte[] namespace,
                                byte[] qualifier)
```
  - valueOf
```
public static TableName valueOf(ByteBuffer namespace,
                                ByteBuffer qualifier)
```
  - equals
```
public boolean equals(Object o)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - compareTo
```
public int compareTo(TableName tableName)
```
    Specified by:
    
    compareTo in interface Comparable<TableName>

Class TableName

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

NAMESPACE_DELIM

VALID_NAMESPACE_REGEX

VALID_TABLE_QUALIFIER_REGEX

VALID_USER_TABLE_REGEX

META_TABLE_NAME

NAMESPACE_TABLE_NAME

OLD_META_STR

OLD_ROOT_STR

DISALLOWED_TABLE_NAME

OLD_ROOT_TABLE_NAME

OLD_META_TABLE_NAME

Method Detail

isMetaTableName

isLegalFullyQualifiedTableName

isLegalTableQualifierName

isLegalTableQualifierName

isLegalTableQualifierName

isLegalTableQualifierName

isLegalNamespaceName

isLegalNamespaceName

getName

getNameAsString

getNamespace

getNamespaceAsString

getNameWithNamespaceInclAsString

getQualifier

getQualifierAsString

toBytes

isSystemTable

toString

valueOf

valueOf

valueOf

valueOf

valueOf

valueOf

valueOf

equals

hashCode

compareTo