Features supported by Tablestore HBase Client - Tablestore

When you use Tablestore, Tablestore hides infrastructure details such as table splitting, Dump, Compact, and Region Server. You need to only pay attention to data usage. Tablestore and HBase have similar data models and features. However, Tablestore HBase Client and the native HBase API have specific differences. This topic describes the features and operations supported by Tablestore HBase Client.

Supported features

CreateTable

Tablestore does not support ColumnFamily and all data can be considered to be in the same ColumnFamily. Therefore, the time to live (TTL) and max versions of Tablestore are at the data table level. The following table describes the features supported by Tablestore HBase Client.

Feature	Supported
family max version	Supported at the table level. Default value: 1.
family min version	No
family ttl	Supported at the table level.
is/set ReadOnly	Supported for RAM users.
Pre-partitioning	No
blockcache	No
blocksize	No
BloomFilter	No
column max version	No
cell ttl	No
Parameter for management and control	No

Put

Feature	Supported
Write multiple columns of data at the same time	Yes
Specify a timestamp	Yes
Use the system time when no timestamp is specified	Yes
Access control list (ACL) for a single row	No
ttl	No
Cell Visibility	No
tag	No

Get

Tablestore ensures high data consistency. If the HTTP 200 status code (OK) is returned after you perform a write operation, the data is permanently written to all copies, and can be immediately read by Get operations.

Feature	Supported
Read a single row of data	Yes
Read all columns in a ColumnFamily	Yes
Read data from a specific column	Yes
Read data that has a specific timestamp	Yes
Read data of a specific number of versions	Yes
TimeRange	Yes
ColumnfamilyTimeRange	No
RowOffsetPerColumnFamily	Yes
MaxResultsPerColumnFamily	No
checkExistenceOnly	No
closestRowBefore	Yes
attribute	No
cacheblock:true	Yes
cacheblock:false	No
IsolationLevel:READ_COMMITTED	Yes
IsolationLevel:READ_UNCOMMITTED	No
IsolationLevel:STRONG	Yes
IsolationLevel:TIMELINE	No

Scan

Feature	Supported
Determine a scanning range based on the specified start and stop parameters	Yes
Globally scan data when no scanning range is specified	Yes
prefix filter	Yes
Read data by using the same logic as Get operations	Yes
Read data in reverse order	Yes
caching	Yes
batch	No
maxResultSize, which indicates the maximum size of the returned data volume	No
small	No
cacheblock:true	Yes
cacheblock:false	No
IsolationLevel:READ_COMMITTED	Yes
IsolationLevel:READ_UNCOMMITTED	No
IsolationLevel:STRONG	Yes
IsolationLevel:TIMELINE	No
allowPartialResults	No

Batch

Feature	Supported
Get	Yes
Put	Yes
Delete	Yes
batchCallback	No

Delete

Feature	Supported
Delete a row	Yes
Delete all versions of data from a specific column	Yes
Delete a specific version of data from a specific column	Yes
Delete the specified ColumnFamily	No
Specify a timestamp to delete the versions that are equal to the timestamp	Yes
Specify a timestamp and use deleteFamily and deleteColumns to delete the versions that are earlier than or equal to the timestamp	No
Use deleteColumn to delete the latest version when no timestamp is specified	No
Use deleteFamily and deleteColumns to delete the version of the current system time when no timestamp is specified	No
addDeleteMarker	No

checkAndXXX

Feature	Supported
CheckAndPut	Yes
checkAndMutate	Yes
CheckAndDelete	Yes
Check whether the value of a column meets the conditions. If yes, checkAndXXX deletes the row.	Yes
Use the default value when no value is specified	Yes
Check row A and perform operations on row B.	No

exist

Feature	Supported
Check whether one or more rows exist and return no content.	Yes

Filter

Feature	Supported
ColumnPaginationFilter	columnOffset and count not supported
ColumnRangeFilter	Yes
FilterList	The combination and nesting of ColumnRangeFilter, ColumnValueFilter, and ColumnPaginationFilter can be included in FilterList.
SingleColumnValueFilter	Supported: LongComparator, BinaryComparator, and ByteArrayComparable Not supported: RegexStringComparator, SubstringComparator, and BitComparator

Method not supported

The following table describes the methods that are not supported by specific modules.

Module	Method not supported
Table	Tablestore supports only single-column families.
Row and Cell	Access control lists (ACLs) are not supported. Cell visibility is not supported. Tags are not supported.
GET	Tablestore supports only single-column families. Therefore, Tablestore does not support the methods that are related to column families. `setColumnFamilyTimeRange(byte[] cf, long minStamp, long maxStamp)` `setMaxResultsPerColumnFamily(int limit)` `setRowOffsetPerColumnFamily(int offset)`
SCAN	Partial optimization methods are not supported because Tablestore does not support the methods that are related to column families. The SCAN operation is similar to the GET operation. The following optimization methods are not supported: `setBatch(int batch)` `setMaxResultSize(long maxResultSize)` `setAllowPartialResults(boolean allowPartialResults)` `setLoadColumnFamiliesOnDemand(boolean value)` `setSmall(boolean small)`
Batch	BatchCallback is not supported.
Mutations and Deletions	You cannot delete a specific column family. You cannot delete a version that has the latest timestamp. You cannot delete all versions that have a timestamp earlier than the specified timestamp.
Increment and Append	Tablestore does not support atomic increase and decrease or atomic Append.
Optimization	Specific HBase methods involve access and storage optimization and are not available in Tablestore. The following parameters are not supported: blockcache: Default value: true. You cannot modify the default value. blocksize: Default value: 64. Unit: KB. You cannot modify the default value. IsolationLevel: Default value: READ_COMMITTED. You cannot modify the default value. Consistency: Default value: STRONG. You cannot modify the default value.
Admin	The methods of `org.apache.hadoop.hbase.client.Admin` of HBase are used for management and control, most of which are not required in Tablestore. Tablestore is a cloud service that automatically performs the operations that are related to O&M, management, and control. Therefore, Tablestore does not support the methods that are related to these operations. CreateTable Tablestore supports only single-column families. You can create only one column family when you create a table. The column family supports the MaxVersions and TimeToLive parameters. Maintenance task In Tablestore, the following operations related to task maintenance are automatically processed: `abort(String why, Throwable e)` `balancer()` `enableCatalogJanitor(boolean enable)` `getMasterInfoPort()` `isCatalogJanitorEnabled()` `rollWALWriter(ServerName serverName) -runCatalogScan()` `setBalancerRunning(boolean on, boolean synchronous)` `updateConfiguration(ServerName serverName)` `updateConfiguration()` `stopMaster()` `shutdown()` Namespaces Tablestore uses instances to manage data tables. An instance is the minimum billing unit in Tablestore. You can manage instances in the Tablestore console. The following methods are not supported: `createNamespace(NamespaceDescriptor descriptor)` `deleteNamespace(String name)` `getNamespaceDescriptor(String name)` `listNamespaceDescriptors()` `listTableDescriptorsByNamespace(String name)` `listTableNamesByNamespace(String name)` `modifyNamespace(NamespaceDescriptor descriptor)` Region management Partition is the basic unit for data storage and management in Tablestore. Tablestore automatically splits or merges the partitions based on the data volumes and access conditions of the partitions. Therefore, Tablestore does not support methods that are related to region management. `assign(byte[] regionName)` `closeRegion(byte[] regionname, String serverName)` `closeRegion(ServerName sn, HRegionInfo hri)` `closeRegion(String regionname, String serverName)` `closeRegionWithEncodedRegionName(String encodedRegionName, String serverName)` `compactRegion(byte[] regionName)` `compactRegion(byte[] regionName, byte[] columnFamily)` `compactRegionServer(ServerName sn, boolean major)` `flushRegion(byte[] regionName)` `getAlterStatus(byte[] tableName)` `getAlterStatus(TableName tableName)` `getCompactionStateForRegion(byte[] regionName)` `getOnlineRegions(ServerName sn)` `majorCompactRegion(byte[] regionName)` `majorCompactRegion(byte[] regionName, byte[] columnFamily)` `mergeRegions(byte[] encodedNameOfRegionA, byte[] encodedNameOfRegionB, boolean forcible)` `move(byte[] encodedRegionName, byte[] destServerName)` `offline(byte[] regionName)` `splitRegion(byte[] regionName)` `splitRegion(byte[] regionName, byte[] splitPoint)` `stopRegionServer(String hostnamePort)` `unassign(byte[] regionName, boolean force)`
Snapshots	Tablestore does not support Snapshots, or methods related to Snapshots.
Replication	Tablestore does not support Replication, or methods related to Replication.
Table management	Tablestore automatically splits, merges, and compacts partitions in tables. Therefore, the following methods are not supported: `getTableDescriptor(TableName tableName)` `compact(TableName tableName)` `compact(TableName tableName, byte[] columnFamily)` `flush(TableName tableName)` `getCompactionState(TableName tableName)` `majorCompact(TableName tableName)` `majorCompact(TableName tableName, byte[] columnFamily)` `modifyTable(TableName tableName, HTableDescriptor htd)` `split(TableName tableName)` `split(TableName tableName, byte[] splitPoint)`
Coprocessors	Tablestore does not support coprocessor. Therefore, the following methods are not supported: `coprocessorService()` `coprocessorService(ServerName serverName)` `getMasterCoprocessors()`
Distributed procedures	Tablestore does not support distributed procedures. Therefore, the following methods are not supported: `execProcedure(String signature, String instance, Map props)` `execProcedureWithRet(String signature, String instance, Map props)` `isProcedureFinished(String signature, String instance, Map props)`

Limits

Tablestore is a cloud service. To ensure an optimal overall performance, limits are imposed on specific parameters and you cannot modify the limits. For more information, see General limits.