HTableDescriptor (Apache HBase 1.2.12 API)

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

All Implemented Interfaces:

Comparable<HTableDescriptor>, org.apache.hadoop.io.Writable, org.apache.hadoop.io.WritableComparable<HTableDescriptor>

Direct Known Subclasses:

UnmodifyableHTableDescriptor
```
@InterfaceAudience.Public
@InterfaceStability.Evolving
public class HTableDescriptor
extends Object
implements org.apache.hadoop.io.WritableComparable<HTableDescriptor>
```
HTableDescriptor contains the details about an HBase table such as the descriptors of all the column families, is the table a catalog table, -ROOT- or hbase:meta , if the table is read only, the maximum size of the memstore, when the region split should occur, coprocessors associated with it etc...

Field Summary

Fields
Modifier and Type	Field and Description
`static String`	`COMPACTION_ENABLED` INTERNAL Used by HBase Shell interface to access this metadata attribute which denotes if the table is compaction enabled
`private static ImmutableBytesWritable`	`COMPACTION_ENABLED_KEY`
`private Map<String,String>`	`configuration` A map which holds the configuration specific to the table.
`static boolean`	`DEFAULT_COMPACTION_ENABLED` Constant that denotes whether the table is compaction enabled by default
`private static boolean`	`DEFAULT_DEFERRED_LOG_FLUSH`
`private static Durability`	`DEFAULT_DURABLITY` Default durability for HTD is USE_DEFAULT, which defaults to HBase-global default value
`static long`	`DEFAULT_MEMSTORE_FLUSH_SIZE` Constant that denotes the maximum default size of the memstore after which the contents are flushed to the store files
`static boolean`	`DEFAULT_NORMALIZATION_ENABLED` Constant that denotes whether the table is normalized by default.
`static boolean`	`DEFAULT_READONLY` Constant that denotes whether the table is READONLY by default and is false
`static boolean`	`DEFAULT_REGION_MEMSTORE_REPLICATION`
`static int`	`DEFAULT_REGION_REPLICATION`
`private static Map<String,String>`	`DEFAULT_VALUES`
`static String`	`DEFERRED_LOG_FLUSH` Deprecated. Use `DURABILITY` instead.
`private static ImmutableBytesWritable`	`DEFERRED_LOG_FLUSH_KEY` Deprecated.
`private Durability`	`durability` Durability setting for the table
`static String`	`DURABILITY` INTERNAL `Durability` setting for the table.
`private static ImmutableBytesWritable`	`DURABILITY_KEY`
`private static ImmutableBytesWritable`	`FALSE`
`private Map<byte[],HColumnDescriptor>`	`families` Maps column family name to the respective HColumnDescriptors
`static String`	`FLUSH_POLICY`
`static String`	`IS_META` INTERNAL Used by rest interface to access this metadata attribute which denotes if it is a catalog table, either `hbase:meta` or `-ROOT-`
`private static ImmutableBytesWritable`	`IS_META_KEY`
`static String`	`IS_ROOT` INTERNAL Used by rest interface to access this metadata attribute which denotes if the table is a -ROOT- region or not
`private static ImmutableBytesWritable`	`IS_ROOT_KEY`
`private static org.apache.commons.logging.Log`	`LOG`
`static String`	`MAX_FILESIZE` INTERNAL Used by HBase Shell interface to access this metadata attribute which denotes the maximum size of the store file after which a region split occurs
`private static ImmutableBytesWritable`	`MAX_FILESIZE_KEY`
`static String`	`MEMSTORE_FLUSHSIZE` INTERNAL Used by HBase Shell interface to access this metadata attribute which represents the maximum size of the memstore after which its contents are flushed onto the disk
`private static ImmutableBytesWritable`	`MEMSTORE_FLUSHSIZE_KEY`
`private Boolean`	`meta` Cache of whether this is a meta table or not.
`static HTableDescriptor`	`META_TABLEDESC` Deprecated. Use TableDescriptors#get(TableName.META_TABLE_NAME) or HBaseAdmin#getTableDescriptor(TableName.META_TABLE_NAME) instead.
`private TableName`	`name`
`static byte[]`	`NAMESPACE_COL_DESC_BYTES`
`static String`	`NAMESPACE_FAMILY_INFO`
`static byte[]`	`NAMESPACE_FAMILY_INFO_BYTES`
`static HTableDescriptor`	`NAMESPACE_TABLEDESC` Table descriptor for namespace table
`static String`	`NORMALIZATION_ENABLED` INTERNAL Used by shell/rest interface to access this metadata attribute which denotes if the table should be treated by region normalizer.
`private static ImmutableBytesWritable`	`NORMALIZATION_ENABLED_KEY`
`static String`	`OWNER`
`static ImmutableBytesWritable`	`OWNER_KEY`
`static String`	`READONLY` INTERNAL Used by rest interface to access this metadata attribute which denotes if the table is Read Only
`private static ImmutableBytesWritable`	`READONLY_KEY`
`static String`	`REGION_MEMSTORE_REPLICATION` INTERNAL flag to indicate whether or not the memstore should be replicated for read-replicas (CONSISTENCY => TIMELINE).
`private static ImmutableBytesWritable`	`REGION_MEMSTORE_REPLICATION_KEY`
`static String`	`REGION_REPLICATION` INTERNAL number of region replicas for the table.
`private static ImmutableBytesWritable`	`REGION_REPLICATION_KEY`
`private static Set<ImmutableBytesWritable>`	`RESERVED_KEYWORDS`
`private Boolean`	`root` Cache of whether this is root table or not.
`static String`	`SPLIT_POLICY`
`private static byte`	`TABLE_DESCRIPTOR_VERSION` Changes prior to version 3 were not recorded here.
`private static ImmutableBytesWritable`	`TRUE`
`private Map<ImmutableBytesWritable,ImmutableBytesWritable>`	`values` A map which holds the metadata information of the table.

Constructor Summary

Constructors
Modifier	Constructor and Description
	`HTableDescriptor()` Deprecated. As of release 0.96 (HBASE-5453). This will be removed in HBase 2.0.0. Used by Writables and Writables are going away.
	`HTableDescriptor(byte[] name)` Deprecated.
	`HTableDescriptor(HTableDescriptor desc)` Construct a table descriptor by cloning the descriptor passed as a parameter.
	`HTableDescriptor(String name)` Deprecated.
	`HTableDescriptor(TableName name)` Construct a table descriptor specifying a TableName object
`protected`	`HTableDescriptor(TableName name, HColumnDescriptor[] families)` INTERNAL Private constructor used internally creating table descriptors for catalog tables, `hbase:meta` and `-ROOT-`.
`protected`	`HTableDescriptor(TableName name, HColumnDescriptor[] families, Map<ImmutableBytesWritable,ImmutableBytesWritable> values)` INTERNAL Private constructor used internally creating table descriptors for catalog tables, `hbase:meta` and `-ROOT-`.
	`HTableDescriptor(TableName name, HTableDescriptor desc)` Construct a table descriptor by cloning the descriptor passed as a parameter but using a different table name.

Method Summary

Methods
Modifier and Type	Method and Description
`HTableDescriptor`	`addCoprocessor(String className)` Add a table coprocessor to this table.
`HTableDescriptor`	`addCoprocessor(String className, org.apache.hadoop.fs.Path jarFilePath, int priority, Map<String,String> kvs)` Add a table coprocessor to this table.
`private HTableDescriptor`	`addCoprocessorToMap(String specStr)` Add coprocessor to values Map
`HTableDescriptor`	`addCoprocessorWithSpec(String specStr)` Add a table coprocessor to this table.
`HTableDescriptor`	`addFamily(HColumnDescriptor family)` Adds a column family.
`private Boolean`	`calculateIsMetaRegion()`
`private void`	`checkHasCoprocessor(String className)`
`int`	`compareTo(HTableDescriptor other)` Compares the descriptor with another descriptor which is passed as a parameter.
`org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.TableSchema`	`convert()`
`static HTableDescriptor`	`convert(org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.TableSchema ts)`
`boolean`	`equals(Object obj)` Compare the contents of the descriptor with another one passed as a parameter.
`HColumnDescriptor[]`	`getColumnFamilies()` Returns an array all the `HColumnDescriptor` of the column families of the table.
`Map<String,String>`	`getConfiguration()` Getter for fetching an unmodifiable `configuration` map.
`String`	`getConfigurationValue(String key)` Getter for accessing the configuration value by key
`private static String`	`getCoprocessorClassNameFromSpecStr(String spec)`
`List<String>`	`getCoprocessors()` Return the list of attached co-processor represented by their name className
`Durability`	`getDurability()` Returns the durability setting for the table.
`Collection<HColumnDescriptor>`	`getFamilies()` Returns an unmodifiable collection of all the `HColumnDescriptor` of all the column families of the table.
`Set<byte[]>`	`getFamiliesKeys()` Returns all the column family names of the current table.
`HColumnDescriptor`	`getFamily(byte[] column)` Returns the HColumnDescriptor for a specific column family with name as specified by the parameter column.
`String`	`getFlushPolicyClassName()` This gets the class associated with the flush policy which determines the stores need to be flushed when flushing a region.
`long`	`getMaxFileSize()` Returns the maximum size upto which a region can grow to after which a region split is triggered.
`long`	`getMemStoreFlushSize()` Returns the size of the memstore after which a flush to filesystem is triggered.
`byte[]`	`getName()` Deprecated. Use `getTableName()` instead
`String`	`getNameAsString()` Get the name of the table as a String
`String`	`getOwnerString()` Deprecated.
`int`	`getRegionReplication()` Returns the configured replicas per region
`String`	`getRegionSplitPolicyClassName()` This gets the class associated with the region split policy which determines when a region split should occur.
`static org.apache.hadoop.fs.Path`	`getTableDir(org.apache.hadoop.fs.Path rootdir, byte[] tableName)` Deprecated.
`TableName`	`getTableName()` Get the name of the table
`byte[]`	`getValue(byte[] key)` Getter for accessing the metadata associated with the key
`private byte[]`	`getValue(ImmutableBytesWritable key)`
`String`	`getValue(String key)` Getter for accessing the metadata associated with the key
`Map<ImmutableBytesWritable,ImmutableBytesWritable>`	`getValues()` Getter for fetching an unmodifiable `values` map.
`private StringBuilder`	`getValues(boolean printDefaults)`
`boolean`	`hasCoprocessor(String classNameToMatch)` Check if the table has an attached co-processor represented by the name className
`boolean`	`hasFamily(byte[] familyName)` Checks to see if this table contains the given column family
`int`	`hashCode()`
`boolean`	`hasRegionMemstoreReplication()`
`boolean`	`isCompactionEnabled()` Check if the compaction enable flag of the table is true.
`boolean`	`isMetaRegion()` Checks if this table is `hbase:meta` region.
`boolean`	`isMetaTable()` Checks if the table is a `hbase:meta` table
`boolean`	`isNormalizationEnabled()` Check if normalization enable flag of the table is true.
`boolean`	`isReadOnly()` Check if the readOnly flag of the table is set.
`boolean`	`isRootRegion()` Check if the descriptor represents a `-ROOT-` region.
`private boolean`	`isSomething(ImmutableBytesWritable key, boolean valueIfNull)`
`static HTableDescriptor`	`metaTableDescriptor(org.apache.hadoop.conf.Configuration conf)`
`HTableDescriptor`	`modifyFamily(HColumnDescriptor family)` Modifies the existing column family.
`static HTableDescriptor`	`parseFrom(byte[] bytes)`
`void`	`readFields(DataInput in)` Deprecated. Writables are going away. Use pb `parseFrom(byte[])` instead.
`void`	`remove(byte[] key)` Remove metadata represented by the key from the `values` map
`void`	`remove(ImmutableBytesWritable key)` Remove metadata represented by the key from the `values` map
`void`	`remove(String key)` Remove metadata represented by the key from the `values` map
`void`	`removeConfiguration(String key)` Remove a config setting represented by the key from the `configuration` map
`void`	`removeCoprocessor(String className)` Remove a coprocessor from those set on the table
`HColumnDescriptor`	`removeFamily(byte[] column)` Removes the HColumnDescriptor with name specified by the parameter column from the table descriptor
`HTableDescriptor`	`setCompactionEnabled(boolean isEnable)` Setting the table compaction enable flag.
`HTableDescriptor`	`setConfiguration(String key, String value)` Setter for storing a configuration setting in `configuration` map.
`HTableDescriptor`	`setDurability(Durability durability)` Sets the `Durability` setting for the table.
`HTableDescriptor`	`setFlushPolicyClassName(String clazz)` This sets the class associated with the flush policy which determines determines the stores need to be flushed when flushing a region.
`HTableDescriptor`	`setMaxFileSize(long maxFileSize)` Sets the maximum size upto which a region can grow to after which a region split is triggered.
`HTableDescriptor`	`setMemStoreFlushSize(long memstoreFlushSize)` Represents the maximum size of the memstore after which the contents of the memstore are flushed to the filesystem.
`private void`	`setMetaFlags(TableName name)`
`protected void`	`setMetaRegion(boolean isMeta)` INTERNAL Used to denote if the current table represents `-ROOT-` or `hbase:meta` region.
`HTableDescriptor`	`setName(byte[] name)` Deprecated.
`HTableDescriptor`	`setName(TableName name)` Deprecated.
`HTableDescriptor`	`setNormalizationEnabled(boolean isEnable)` Setting the table normalization enable flag.
`HTableDescriptor`	`setOwner(User owner)` Deprecated.
`HTableDescriptor`	`setOwnerString(String ownerString)` Deprecated.
`HTableDescriptor`	`setReadOnly(boolean readOnly)` Setting the table as read only sets all the columns in the table as read only.
`HTableDescriptor`	`setRegionMemstoreReplication(boolean memstoreReplication)` Enable or Disable the memstore replication from the primary region to the replicas.
`HTableDescriptor`	`setRegionReplication(int regionReplication)` Sets the number of replicas per region.
`HTableDescriptor`	`setRegionSplitPolicyClassName(String clazz)` This sets the class associated with the region split policy which determines when a region split should occur.
`protected void`	`setRootRegion(boolean isRoot)` INTERNAL Used to denote if the current table represents `-ROOT-` region.
`HTableDescriptor`	`setValue(byte[] key, byte[] value)` Setter for storing metadata as a (key, value) pair in `values` map
`HTableDescriptor`	`setValue(ImmutableBytesWritable key, ImmutableBytesWritable value)`
`private HTableDescriptor`	`setValue(ImmutableBytesWritable key, String value)`
`HTableDescriptor`	`setValue(String key, String value)` Setter for storing metadata as a (key, value) pair in `values` map
`byte[]`	`toByteArray()`
`String`	`toString()`
`String`	`toStringCustomizedValues()`
`String`	`toStringTableAttributes()`
`void`	`write(DataOutput out)` Deprecated. Writables are going away. Use `MessageLite.toByteArray()` instead.

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

- Field Detail
  - LOG
```
private static final org.apache.commons.logging.Log LOG
```
  - TABLE_DESCRIPTOR_VERSION
```
private static final byte TABLE_DESCRIPTOR_VERSION
```
    Changes prior to version 3 were not recorded here. Version 3 adds metadata as a map where keys and values are byte[]. Version 4 adds indexes Version 5 removed transactional pollution -- e.g. indexes Version 6 changed metadata to BytesBytesPair in PB Version 7 adds table-level configuration
    
    See Also:
    Constant Field Values
  - name
```
private TableName name
```
  - values
```
private final Map<ImmutableBytesWritable,ImmutableBytesWritable> values
```
    A map which holds the metadata information of the table. This metadata includes values like IS_ROOT, IS_META, DEFERRED_LOG_FLUSH, SPLIT_POLICY, MAX_FILE_SIZE, READONLY, MEMSTORE_FLUSHSIZE etc...
  - configuration
```
private final Map<String,String> configuration
```
    A map which holds the configuration specific to the table. The keys of the map have the same names as config keys and override the defaults with table-specific settings. Example usage may be for compactions, etc.
  - SPLIT_POLICY
```
public static final String SPLIT_POLICY
```
    See Also:
    Constant Field Values
  - MAX_FILESIZE
```
public static final String MAX_FILESIZE
```
    INTERNAL Used by HBase Shell interface to access this metadata attribute which denotes the maximum size of the store file after which a region split occurs
    
    See Also:
    getMaxFileSize(), Constant Field Values
  - MAX_FILESIZE_KEY
```
private static final ImmutableBytesWritable MAX_FILESIZE_KEY
```
  - OWNER
```
public static final String OWNER
```
    See Also:
    Constant Field Values
  - OWNER_KEY
```
public static final ImmutableBytesWritable OWNER_KEY
```
  - READONLY
```
public static final String READONLY
```
    INTERNAL Used by rest interface to access this metadata attribute which denotes if the table is Read Only
    
    See Also:
    isReadOnly(), Constant Field Values
  - READONLY_KEY
```
private static final ImmutableBytesWritable READONLY_KEY
```
  - COMPACTION_ENABLED
```
public static final String COMPACTION_ENABLED
```
    INTERNAL Used by HBase Shell interface to access this metadata attribute which denotes if the table is compaction enabled
    
    See Also:
    isCompactionEnabled(), Constant Field Values
  - COMPACTION_ENABLED_KEY
```
private static final ImmutableBytesWritable COMPACTION_ENABLED_KEY
```
  - MEMSTORE_FLUSHSIZE
```
public static final String MEMSTORE_FLUSHSIZE
```
    INTERNAL Used by HBase Shell interface to access this metadata attribute which represents the maximum size of the memstore after which its contents are flushed onto the disk
    
    See Also:
    getMemStoreFlushSize(), Constant Field Values
  - MEMSTORE_FLUSHSIZE_KEY
```
private static final ImmutableBytesWritable MEMSTORE_FLUSHSIZE_KEY
```
  - FLUSH_POLICY
```
public static final String FLUSH_POLICY
```
    See Also:
    Constant Field Values
  - IS_ROOT
```
public static final String IS_ROOT
```
    INTERNAL Used by rest interface to access this metadata attribute which denotes if the table is a -ROOT- region or not
    
    See Also:
    isRootRegion(), Constant Field Values
  - IS_ROOT_KEY
```
private static final ImmutableBytesWritable IS_ROOT_KEY
```
  - IS_META
```
public static final String IS_META
```
    INTERNAL Used by rest interface to access this metadata attribute which denotes if it is a catalog table, either hbase:meta or -ROOT-
    
    See Also:
    isMetaRegion(), Constant Field Values
  - IS_META_KEY
```
private static final ImmutableBytesWritable IS_META_KEY
```
  - DEFERRED_LOG_FLUSH
```
@Deprecated
public static final String DEFERRED_LOG_FLUSH
```
    Deprecated. Use DURABILITY instead.
    
    INTERNAL Used by HBase Shell interface to access this metadata attribute which denotes if the deferred log flush option is enabled.
    
    See Also:
    Constant Field Values
  - DEFERRED_LOG_FLUSH_KEY
```
@Deprecated
private static final ImmutableBytesWritable DEFERRED_LOG_FLUSH_KEY
```
    Deprecated.
  - DURABILITY
```
public static final String DURABILITY
```
    INTERNAL Durability setting for the table.
    
    See Also:
    Constant Field Values
  - DURABILITY_KEY
```
private static final ImmutableBytesWritable DURABILITY_KEY
```
  - REGION_REPLICATION
```
public static final String REGION_REPLICATION
```
    INTERNAL number of region replicas for the table.
    
    See Also:
    Constant Field Values
  - REGION_REPLICATION_KEY
```
private static final ImmutableBytesWritable REGION_REPLICATION_KEY
```
  - REGION_MEMSTORE_REPLICATION
```
public static final String REGION_MEMSTORE_REPLICATION
```
    INTERNAL flag to indicate whether or not the memstore should be replicated for read-replicas (CONSISTENCY => TIMELINE).
    
    See Also:
    Constant Field Values
  - REGION_MEMSTORE_REPLICATION_KEY
```
private static final ImmutableBytesWritable REGION_MEMSTORE_REPLICATION_KEY
```
  - NORMALIZATION_ENABLED
```
public static final String NORMALIZATION_ENABLED
```
    INTERNAL Used by shell/rest interface to access this metadata attribute which denotes if the table should be treated by region normalizer.
    
    See Also:
    isNormalizationEnabled(), Constant Field Values
  - NORMALIZATION_ENABLED_KEY
```
private static final ImmutableBytesWritable NORMALIZATION_ENABLED_KEY
```
  - DEFAULT_DURABLITY
```
private static final Durability DEFAULT_DURABLITY
```
    Default durability for HTD is USE_DEFAULT, which defaults to HBase-global default value
  - FALSE
```
private static final ImmutableBytesWritable FALSE
```
  - TRUE
```
private static final ImmutableBytesWritable TRUE
```
  - DEFAULT_DEFERRED_LOG_FLUSH
```
private static final boolean DEFAULT_DEFERRED_LOG_FLUSH
```
    See Also:
    Constant Field Values
  - DEFAULT_READONLY
```
public static final boolean DEFAULT_READONLY
```
    Constant that denotes whether the table is READONLY by default and is false
    
    See Also:
    Constant Field Values
  - DEFAULT_COMPACTION_ENABLED
```
public static final boolean DEFAULT_COMPACTION_ENABLED
```
    Constant that denotes whether the table is compaction enabled by default
    
    See Also:
    Constant Field Values
  - DEFAULT_NORMALIZATION_ENABLED
```
public static final boolean DEFAULT_NORMALIZATION_ENABLED
```
    Constant that denotes whether the table is normalized by default.
    
    See Also:
    Constant Field Values
  - DEFAULT_MEMSTORE_FLUSH_SIZE
```
public static final long DEFAULT_MEMSTORE_FLUSH_SIZE
```
    Constant that denotes the maximum default size of the memstore after which the contents are flushed to the store files
    
    See Also:
    Constant Field Values
  - DEFAULT_REGION_REPLICATION
```
public static final int DEFAULT_REGION_REPLICATION
```
    See Also:
    Constant Field Values
  - DEFAULT_REGION_MEMSTORE_REPLICATION
```
public static final boolean DEFAULT_REGION_MEMSTORE_REPLICATION
```
    See Also:
    Constant Field Values
  - DEFAULT_VALUES
```
private static final Map<String,String> DEFAULT_VALUES
```
  - RESERVED_KEYWORDS
```
private static final Set<ImmutableBytesWritable> RESERVED_KEYWORDS
```
  - meta
```
private volatile Boolean meta
```
    Cache of whether this is a meta table or not.
  - root
```
private volatile Boolean root
```
    Cache of whether this is root table or not.
  - durability
```
private Durability durability
```
    Durability setting for the table
  - families
```
private final Map<byte[],HColumnDescriptor> families
```
    Maps column family name to the respective HColumnDescriptors
  - META_TABLEDESC
```
@Deprecated
public static final HTableDescriptor META_TABLEDESC
```
    Deprecated. Use TableDescriptors#get(TableName.META_TABLE_NAME) or HBaseAdmin#getTableDescriptor(TableName.META_TABLE_NAME) instead.
    
    Table descriptor for hbase:meta catalog table
  - NAMESPACE_FAMILY_INFO
```
public static final String NAMESPACE_FAMILY_INFO
```
    See Also:
    Constant Field Values
  - NAMESPACE_FAMILY_INFO_BYTES
```
public static final byte[] NAMESPACE_FAMILY_INFO_BYTES
```
  - NAMESPACE_COL_DESC_BYTES
```
public static final byte[] NAMESPACE_COL_DESC_BYTES
```
  - NAMESPACE_TABLEDESC
```
public static final HTableDescriptor NAMESPACE_TABLEDESC
```
    Table descriptor for namespace table
- Constructor Detail
  - HTableDescriptor
```
@InterfaceAudience.Private
protected HTableDescriptor(TableName name,
                                          HColumnDescriptor[] families)
```
    INTERNAL Private constructor used internally creating table descriptors for catalog tables, hbase:meta and -ROOT-.
  - HTableDescriptor
```
protected HTableDescriptor(TableName name,
                HColumnDescriptor[] families,
                Map<ImmutableBytesWritable,ImmutableBytesWritable> values)
```
    INTERNAL Private constructor used internally creating table descriptors for catalog tables, hbase:meta and -ROOT-.
  - HTableDescriptor
```
@Deprecated
public HTableDescriptor()
```
    Deprecated. As of release 0.96 (HBASE-5453). This will be removed in HBase 2.0.0. Used by Writables and Writables are going away.
    
    Default constructor which constructs an empty object. For deserializing an HTableDescriptor instance only.
  - HTableDescriptor
```
public HTableDescriptor(TableName name)
```
    Construct a table descriptor specifying a TableName object
    
    Parameters:
    name - Table name.
    See Also:
    HADOOP-1581 HBASE: (HBASE-174) Un-openable tablename bug
  - HTableDescriptor
```
@Deprecated
public HTableDescriptor(byte[] name)
```
    Deprecated.
    
    Construct a table descriptor specifying a byte array table name
    
    Parameters:
    name - Table name.
    See Also:
    HADOOP-1581 HBASE: (HBASE-174) Un-openable tablename bug
  - HTableDescriptor
```
@Deprecated
public HTableDescriptor(String name)
```
    Deprecated.
    
    Construct a table descriptor specifying a String table name
    
    Parameters:
    name - Table name.
    See Also:
    HADOOP-1581 HBASE: (HBASE-174) Un-openable tablename bug
  - HTableDescriptor
```
public HTableDescriptor(HTableDescriptor desc)
```
    Construct a table descriptor by cloning the descriptor passed as a parameter.
    Makes a deep copy of the supplied descriptor. Can make a modifiable descriptor from an UnmodifyableHTableDescriptor.
    
    Parameters:
    desc - The descriptor.
  - HTableDescriptor
```
public HTableDescriptor(TableName name,
                HTableDescriptor desc)
```
    Construct a table descriptor by cloning the descriptor passed as a parameter but using a different table name.
    Makes a deep copy of the supplied descriptor. Can make a modifiable descriptor from an UnmodifyableHTableDescriptor.
    
    Parameters:
    name - Table name.
    desc - The descriptor.
- Method Detail
  - setMetaFlags
```
private void setMetaFlags(TableName name)
```
  - isRootRegion
```
public boolean isRootRegion()
```
    Check if the descriptor represents a -ROOT- region.
    
    Returns:
    true if this is a -ROOT- region
  - setRootRegion
```
protected void setRootRegion(boolean isRoot)
```
    INTERNAL Used to denote if the current table represents -ROOT- region. This is used internally by the HTableDescriptor constructors
    
    Parameters:
    isRoot - true if this is the -ROOT- region
  - isMetaRegion
```
public boolean isMetaRegion()
```
    Checks if this table is hbase:meta region.
    
    Returns:
    true if this table is hbase:meta region
  - calculateIsMetaRegion
```
private Boolean calculateIsMetaRegion()
```
  - isSomething
```
private boolean isSomething(ImmutableBytesWritable key,
                  boolean valueIfNull)
```
  - setMetaRegion
```
protected void setMetaRegion(boolean isMeta)
```
    INTERNAL Used to denote if the current table represents -ROOT- or hbase:meta region. This is used internally by the HTableDescriptor constructors
    
    Parameters:
    isMeta - true if its either -ROOT- or hbase:meta region
  - isMetaTable
```
public boolean isMetaTable()
```
    Checks if the table is a hbase:meta table
    
    Returns:
    true if table is hbase:meta region.
  - getValue
```
public byte[] getValue(byte[] key)
```
    Getter for accessing the metadata associated with the key
    
    Parameters:
    key - The key.
    
    Returns:
    The value.
    See Also:
    values
  - getValue
```
private byte[] getValue(ImmutableBytesWritable key)
```
  - getValue
```
public String getValue(String key)
```
    Getter for accessing the metadata associated with the key
    
    Parameters:
    key - The key.
    
    Returns:
    The value.
    See Also:
    values
  - getValues
```
public Map<ImmutableBytesWritable,ImmutableBytesWritable> getValues()
```
    Getter for fetching an unmodifiable values map.
    
    Returns:
    unmodifiable map values.
    See Also:
    values
  - setValue
```
public HTableDescriptor setValue(byte[] key,
                        byte[] value)
```
    Setter for storing metadata as a (key, value) pair in values map
    
    Parameters:
    key - The key.
    value - The value.
    See Also:
    values
  - setValue
```
private HTableDescriptor setValue(ImmutableBytesWritable key,
                        String value)
```
  - setValue
```
public HTableDescriptor setValue(ImmutableBytesWritable key,
                        ImmutableBytesWritable value)
```
  - setValue
```
public HTableDescriptor setValue(String key,
                        String value)
```
    Setter for storing metadata as a (key, value) pair in values map
    
    Parameters:
    key - The key.
    value - The value.
    See Also:
    values
  - remove
```
public void remove(String key)
```
    Remove metadata represented by the key from the values map
    
    Parameters:
    key - Key whose key and value we're to remove from HTableDescriptor parameters.
  - remove
```
public void remove(ImmutableBytesWritable key)
```
    Remove metadata represented by the key from the values map
    
    Parameters:
    key - Key whose key and value we're to remove from HTableDescriptor parameters.
  - remove
```
public void remove(byte[] key)
```
    Remove metadata represented by the key from the values map
    
    Parameters:
    key - Key whose key and value we're to remove from HTableDescriptor parameters.
  - isReadOnly
```
public boolean isReadOnly()
```
    Check if the readOnly flag of the table is set. If the readOnly flag is set then the contents of the table can only be read from but not modified.
    
    Returns:
    true if all columns in the table should be read only
  - setReadOnly
```
public HTableDescriptor setReadOnly(boolean readOnly)
```
    Setting the table as read only sets all the columns in the table as read only. By default all tables are modifiable, but if the readOnly flag is set to true then the contents of the table can only be read but not modified.
    
    Parameters:
    readOnly - True if all of the columns in the table should be read only.
  - isCompactionEnabled
```
public boolean isCompactionEnabled()
```
    Check if the compaction enable flag of the table is true. If flag is false then no minor/major compactions will be done in real.
    
    Returns:
    true if table compaction enabled
  - setCompactionEnabled
```
public HTableDescriptor setCompactionEnabled(boolean isEnable)
```
    Setting the table compaction enable flag.
    
    Parameters:
    isEnable - True if enable compaction.
  - isNormalizationEnabled
```
public boolean isNormalizationEnabled()
```
    Check if normalization enable flag of the table is true. If flag is false then no region normalizer won't attempt to normalize this table.
    
    Returns:
    true if region normalization is enabled for this table
  - setNormalizationEnabled
```
public HTableDescriptor setNormalizationEnabled(boolean isEnable)
```
    Setting the table normalization enable flag.
    
    Parameters:
    isEnable - True if enable normalization.
  - setDurability
```
public HTableDescriptor setDurability(Durability durability)
```
    Sets the Durability setting for the table. This defaults to Durability.USE_DEFAULT.
    
    Parameters:
    durability - enum value
  - getDurability
```
public Durability getDurability()
```
    Returns the durability setting for the table.
    
    Returns:
    durability setting for the table.
  - getTableName
```
public TableName getTableName()
```
    Get the name of the table
    
    Returns:
    TableName
  - getName
```
@Deprecated
public byte[] getName()
```
    Deprecated. Use getTableName() instead
    
    Get the name of the table as a byte array.
    
    Returns:
    name of table
  - getNameAsString
```
public String getNameAsString()
```
    Get the name of the table as a String
    
    Returns:
    name of table as a String
  - setRegionSplitPolicyClassName
```
public HTableDescriptor setRegionSplitPolicyClassName(String clazz)
```
    This sets the class associated with the region split policy which determines when a region split should occur. The class used by default is defined in RegionSplitPolicy
    
    Parameters:
    clazz - the class name
  - getRegionSplitPolicyClassName
```
public String getRegionSplitPolicyClassName()
```
    This gets the class associated with the region split policy which determines when a region split should occur. The class used by default is defined in RegionSplitPolicy
    
    Returns:
    the class name of the region split policy for this table. If this returns null, the default split policy is used.
  - setName
```
@Deprecated
public HTableDescriptor setName(byte[] name)
```
    Deprecated.
    
    Set the name of the table.
    
    Parameters:
    name - name of table
  - setName
```
@Deprecated
public HTableDescriptor setName(TableName name)
```
    Deprecated.
  - getMaxFileSize
```
public long getMaxFileSize()
```
    Returns the maximum size upto which a region can grow to after which a region split is triggered. The region size is represented by the size of the biggest store file in that region.
    
    Returns:
    max hregion size for table, -1 if not set.
    See Also:
    setMaxFileSize(long)
  - setMaxFileSize
```
public HTableDescriptor setMaxFileSize(long maxFileSize)
```
    Sets the maximum size upto which a region can grow to after which a region split is triggered. The region size is represented by the size of the biggest store file in that region, i.e. If the biggest store file grows beyond the maxFileSize, then the region split is triggered. This defaults to a value of 256 MB.
    This is not an absolute value and might vary. Assume that a single row exceeds the maxFileSize then the storeFileSize will be greater than maxFileSize since a single row cannot be split across multiple regions
    
    Parameters:
    maxFileSize - The maximum file size that a store file can grow to before a split is triggered.
  - getMemStoreFlushSize
```
public long getMemStoreFlushSize()
```
    Returns the size of the memstore after which a flush to filesystem is triggered.
    
    Returns:
    memory cache flush size for each hregion, -1 if not set.
    See Also:
    setMemStoreFlushSize(long)
  - setMemStoreFlushSize
```
public HTableDescriptor setMemStoreFlushSize(long memstoreFlushSize)
```
    Represents the maximum size of the memstore after which the contents of the memstore are flushed to the filesystem. This defaults to a size of 64 MB.
    
    Parameters:
    memstoreFlushSize - memory cache flush size for each hregion
  - setFlushPolicyClassName
```
public HTableDescriptor setFlushPolicyClassName(String clazz)
```
    This sets the class associated with the flush policy which determines determines the stores need to be flushed when flushing a region. The class used by default is defined in FlushPolicy
    
    Parameters:
    clazz - the class name
  - getFlushPolicyClassName
```
public String getFlushPolicyClassName()
```
    This gets the class associated with the flush policy which determines the stores need to be flushed when flushing a region. The class used by default is defined in FlushPolicy
    
    Returns:
    the class name of the flush policy for this table. If this returns null, the default flush policy is used.
  - addFamily
```
public HTableDescriptor addFamily(HColumnDescriptor family)
```
    Adds a column family. For the updating purpose please use modifyFamily(HColumnDescriptor) instead.
    
    Parameters:
    family - HColumnDescriptor of family to add.
  - modifyFamily
```
public HTableDescriptor modifyFamily(HColumnDescriptor family)
```
    Modifies the existing column family.
    
    Parameters:
    family - HColumnDescriptor of family to update
    
    Returns:
    this (for chained invocation)
  - hasFamily
```
public boolean hasFamily(byte[] familyName)
```
    Checks to see if this table contains the given column family
    
    Parameters:
    familyName - Family name or column name.
    
    Returns:
    true if the table contains the specified family name
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
    
    Returns:
    Name of this table and then a map of all of the column family descriptors.
    See Also:
    getNameAsString()
  - toStringCustomizedValues
```
public String toStringCustomizedValues()
```
    Returns:
    Name of this table and then a map of all of the column family descriptors (with only the non-default column family attributes)
  - toStringTableAttributes
```
public String toStringTableAttributes()
```
    Returns:
    map of all table attributes formatted into string.
  - getValues
```
private StringBuilder getValues(boolean printDefaults)
```
  - equals
```
public boolean equals(Object obj)
```
    Compare the contents of the descriptor with another one passed as a parameter. Checks if the obj passed is an instance of HTableDescriptor, if yes then the contents of the descriptors are compared.
    
    Overrides:
    
    equals in class Object
    
    Returns:
    true if the contents of the the two descriptors exactly match
    See Also:
    Object.equals(java.lang.Object)
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
    
    See Also:
    Object.hashCode()
  - readFields
```
@Deprecated
public void readFields(DataInput in)
                throws IOException
```
    Deprecated. Writables are going away. Use pb parseFrom(byte[]) instead.
    
    INTERNAL This method is a part of WritableComparable interface and is used for de-serialization of the HTableDescriptor over RPC
    
    Specified by:
    
    readFields in interface org.apache.hadoop.io.Writable
    
    Throws:
    
    IOException
  - write
```
@Deprecated
public void write(DataOutput out)
           throws IOException
```
    Deprecated. Writables are going away. Use MessageLite.toByteArray() instead.
    
    INTERNAL This method is a part of WritableComparable interface and is used for serialization of the HTableDescriptor over RPC
    
    Specified by:
    
    write in interface org.apache.hadoop.io.Writable
    
    Throws:
    
    IOException
  - compareTo
```
public int compareTo(HTableDescriptor other)
```
    Compares the descriptor with another descriptor which is passed as a parameter. This compares the content of the two descriptors and not the reference.
    
    Specified by:
    
    compareTo in interface Comparable<HTableDescriptor>
    
    Returns:
    0 if the contents of the descriptors are exactly matching, 1 if there is a mismatch in the contents
  - getFamilies
```
public Collection<HColumnDescriptor> getFamilies()
```
    Returns an unmodifiable collection of all the HColumnDescriptor of all the column families of the table.
    
    Returns:
    Immutable collection of HColumnDescriptor of all the column families.
  - getRegionReplication
```
public int getRegionReplication()
```
    Returns the configured replicas per region
  - setRegionReplication
```
public HTableDescriptor setRegionReplication(int regionReplication)
```
    Sets the number of replicas per region.
    
    Parameters:
    regionReplication - the replication factor per region
  - hasRegionMemstoreReplication
```
public boolean hasRegionMemstoreReplication()
```
    Returns:
    true if the read-replicas memstore replication is enabled.
  - setRegionMemstoreReplication
```
public HTableDescriptor setRegionMemstoreReplication(boolean memstoreReplication)
```
    Enable or Disable the memstore replication from the primary region to the replicas. The replication will be used only for meta operations (e.g. flush, compaction, ...)
    
    Parameters:
    memstoreReplication - true if the new data written to the primary region should be replicated. false if the secondaries can tollerate to have new data only when the primary flushes the memstore.
  - getFamiliesKeys
```
public Set<byte[]> getFamiliesKeys()
```
    Returns all the column family names of the current table. The map of HTableDescriptor contains mapping of family name to HColumnDescriptors. This returns all the keys of the family map which represents the column family names of the table.
    
    Returns:
    Immutable sorted set of the keys of the families.
  - getColumnFamilies
```
public HColumnDescriptor[] getColumnFamilies()
```
    Returns an array all the HColumnDescriptor of the column families of the table.
    
    Returns:
    Array of all the HColumnDescriptors of the current table
    See Also:
    getFamilies()
  - getFamily
```
public HColumnDescriptor getFamily(byte[] column)
```
    Returns the HColumnDescriptor for a specific column family with name as specified by the parameter column.
    
    Parameters:
    column - Column family name
    
    Returns:
    Column descriptor for the passed family name or the family on passed in column.
  - removeFamily
```
public HColumnDescriptor removeFamily(byte[] column)
```
    Removes the HColumnDescriptor with name specified by the parameter column from the table descriptor
    
    Parameters:
    column - Name of the column family to be removed.
    
    Returns:
    Column descriptor for the passed family name or the family on passed in column.
  - addCoprocessor
```
public HTableDescriptor addCoprocessor(String className)
                                throws IOException
```
    Add a table coprocessor to this table. The coprocessor type must be RegionObserver or Endpoint. It won't check if the class can be loaded or not. Whether a coprocessor is loadable or not will be determined when a region is opened.
    
    Parameters:
    className - Full class name.
    
    Throws:
    
    IOException
  - addCoprocessor
```
public HTableDescriptor addCoprocessor(String className,
                              org.apache.hadoop.fs.Path jarFilePath,
                              int priority,
                              Map<String,String> kvs)
                                throws IOException
```
    Add a table coprocessor to this table. The coprocessor type must be RegionObserver or Endpoint. It won't check if the class can be loaded or not. Whether a coprocessor is loadable or not will be determined when a region is opened.
    
    Parameters:
    jarFilePath - Path of the jar file. If it's null, the class will be loaded from default classloader.
    className - Full class name.
    priority - Priority
    kvs - Arbitrary key-value parameter pairs passed into the coprocessor.
    
    Throws:
    
    IOException
  - addCoprocessorWithSpec
```
public HTableDescriptor addCoprocessorWithSpec(String specStr)
                                        throws IOException
```
    Add a table coprocessor to this table. The coprocessor type must be RegionObserver or Endpoint. It won't check if the class can be loaded or not. Whether a coprocessor is loadable or not will be determined when a region is opened.
    
    Parameters:
    specStr - The Coprocessor specification all in in one String formatted so matches HConstants.CP_HTD_ATTR_VALUE_PATTERN
    
    Throws:
    
    IOException
  - checkHasCoprocessor
```
private void checkHasCoprocessor(String className)
                          throws IOException
```
    Throws:
    
    IOException
  - addCoprocessorToMap
```
private HTableDescriptor addCoprocessorToMap(String specStr)
```
    Add coprocessor to values Map
    
    Parameters:
    specStr - The Coprocessor specification all in in one String formatted so matches HConstants.CP_HTD_ATTR_VALUE_PATTERN
    
    Returns:
    Returns this
  - hasCoprocessor
```
public boolean hasCoprocessor(String classNameToMatch)
```
    Check if the table has an attached co-processor represented by the name className
    
    Parameters:
    classNameToMatch - - Class name of the co-processor
    
    Returns:
    true of the table has a co-processor className
  - getCoprocessors
```
public List<String> getCoprocessors()
```
    Return the list of attached co-processor represented by their name className
    
    Returns:
    The list of co-processors classNames
  - getCoprocessorClassNameFromSpecStr
```
private static String getCoprocessorClassNameFromSpecStr(String spec)
```
    Parameters:
    spec - String formatted as per HConstants.CP_HTD_ATTR_VALUE_PATTERN
    
    Returns:
    Class parsed from passed in spec or null if no match or classpath found
  - removeCoprocessor
```
public void removeCoprocessor(String className)
```
    Remove a coprocessor from those set on the table
    
    Parameters:
    className - Class name of the co-processor
  - getTableDir
```
@Deprecated
public static org.apache.hadoop.fs.Path getTableDir(org.apache.hadoop.fs.Path rootdir,
                                               byte[] tableName)
```
    Deprecated.
    
    Returns the Path object representing the table directory under path rootdir Deprecated use FSUtils.getTableDir() instead.
    
    Parameters:
    rootdir - qualified path of HBase root directory
    tableName - name of table
    
    Returns:
    Path for table
  - setOwner
```
@Deprecated
public HTableDescriptor setOwner(User owner)
```
    Deprecated.
  - setOwnerString
```
@Deprecated
public HTableDescriptor setOwnerString(String ownerString)
```
    Deprecated.
  - getOwnerString
```
@Deprecated
public String getOwnerString()
```
    Deprecated.
  - toByteArray
```
public byte[] toByteArray()
```
    Returns:
    This instance serialized with pb with pb magic prefix
    See Also:
    parseFrom(byte[])
  - parseFrom
```
public static HTableDescriptor parseFrom(byte[] bytes)
                                  throws DeserializationException,
                                         IOException
```
    Parameters:
    bytes - A pb serialized HTableDescriptor instance with pb magic prefix
    
    Returns:
    An instance of HTableDescriptor made from bytes
    
    Throws:
    
    DeserializationException
    
    IOException
    See Also:
    toByteArray()
  - convert
```
public org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.TableSchema convert()
```
    Returns:
    Convert the current HTableDescriptor into a pb TableSchema instance.
  - convert
```
public static HTableDescriptor convert(org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.TableSchema ts)
```
    Parameters:
    ts - A pb TableSchema instance.
    
    Returns:
    An HTableDescriptor made from the passed in pb ts.
  - getConfigurationValue
```
public String getConfigurationValue(String key)
```
    Getter for accessing the configuration value by key
  - getConfiguration
```
public Map<String,String> getConfiguration()
```
    Getter for fetching an unmodifiable configuration map.
  - setConfiguration
```
public HTableDescriptor setConfiguration(String key,
                                String value)
```
    Setter for storing a configuration setting in configuration map.
    
    Parameters:
    key - Config key. Same as XML config key e.g. hbase.something.or.other.
    value - String value. If null, removes the setting.
  - removeConfiguration
```
public void removeConfiguration(String key)
```
    Remove a config setting represented by the key from the configuration map
  - metaTableDescriptor
```
public static HTableDescriptor metaTableDescriptor(org.apache.hadoop.conf.Configuration conf)
                                            throws IOException
```
    Throws:
    
    IOException

Class HTableDescriptor

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LOG

TABLE_DESCRIPTOR_VERSION

name

values

configuration

SPLIT_POLICY

MAX_FILESIZE

MAX_FILESIZE_KEY

OWNER

OWNER_KEY

READONLY

READONLY_KEY

COMPACTION_ENABLED

COMPACTION_ENABLED_KEY

MEMSTORE_FLUSHSIZE

MEMSTORE_FLUSHSIZE_KEY

FLUSH_POLICY

IS_ROOT

IS_ROOT_KEY

IS_META

IS_META_KEY

DEFERRED_LOG_FLUSH

DEFERRED_LOG_FLUSH_KEY

DURABILITY

DURABILITY_KEY

REGION_REPLICATION

REGION_REPLICATION_KEY

REGION_MEMSTORE_REPLICATION

REGION_MEMSTORE_REPLICATION_KEY

NORMALIZATION_ENABLED

NORMALIZATION_ENABLED_KEY

DEFAULT_DURABLITY

FALSE

TRUE

DEFAULT_DEFERRED_LOG_FLUSH

DEFAULT_READONLY

DEFAULT_COMPACTION_ENABLED

DEFAULT_NORMALIZATION_ENABLED

DEFAULT_MEMSTORE_FLUSH_SIZE

DEFAULT_REGION_REPLICATION

DEFAULT_REGION_MEMSTORE_REPLICATION

DEFAULT_VALUES

RESERVED_KEYWORDS

meta

root

durability

families

META_TABLEDESC

NAMESPACE_FAMILY_INFO

NAMESPACE_FAMILY_INFO_BYTES

NAMESPACE_COL_DESC_BYTES

NAMESPACE_TABLEDESC

Constructor Detail

HTableDescriptor

HTableDescriptor

HTableDescriptor

HTableDescriptor

HTableDescriptor

HTableDescriptor

HTableDescriptor

HTableDescriptor

Method Detail

setMetaFlags

isRootRegion

setRootRegion

isMetaRegion

calculateIsMetaRegion

isSomething

setMetaRegion

isMetaTable

getValue

getValue

getValue

getValues