def set_scope(self, scope):
type_check(scope, int)
if scope < 0:
raise RuntimeError(
"Illegal replication scope value {}".format(scope))
self.scope = scope
return self
def get_batch(self, gets):
# type: (List[Get]) -> List[Cell]
"""
Send multiple Get requests to the server at one time.
The requests will be sent batch by batch.
The logger will log the failed position if one batch of requests failed.
Args:
gets: A list of Get objects.
Returns: If success: a list of cells.
If success but not matched data: an empty list.
If get failed: False.
If partly success, a part result will be returned.
"""
type_check(gets, (list, tuple))
for get in gets:
type_check(get, Get)
result_list = []
for i in range(0, len(gets), self.conf.batch_size):
result = self._client._get_rows(table_name=self.name, gets=gets[i: i + self.conf.batch_size])
# if result == False, it shows that the operation failed.
# The task should stop and return the successful part.
if result is False:
return self._results_format(result_list)
elif len(result) > 0:
result_list += result
return self._results_format(result_list)
def add_column(self, col):
type_check(col, TColumnFamilyDescriptor)
for i in range(len(self.columns)):
if col.name == self.columns[i].name:
self.columns[i] = col
return self
self.columns.append(col)
return self
def revoke(self, info):
"""
Args:
info:
Returns:
"""
type_check(info, TAccessControlEntity)
return self.executor.call(lambda: self.client.revoke(info))
def delete(self, delete):
# type: (Delete) -> bool
"""
Send a Delete request to the thrift server.
Args:
delete: a single Delete object
Returns: True if successes, False otherwise.
"""
type_check(delete, Delete)
return self._client._delete_row(table_name=self.name, delete=delete)
def table_exists(self, table_name):
"""
Check if a table exists.
Args:
table_name: type: TTableName
Returns: True if the table exists, else False.
"""
type_check(table_name, str)
tn = str_to_tablename(table_name)
return self.executor.call(lambda: self.client.tableExists(tn))
def put(self, put):
# type: (Put) -> bool
"""
Send a single Put operation to the thrift server.
Args:
put: A customized Get object.
Returns: True if successes, False otherwise.
"""
type_check(put, Put)
return self.executor.call(lambda: self._client._put_row(table_name=self.name, put=put))
def modify_table(self, table_descriptor):
"""
Args:
table_descriptor:
Returns:
"""
type_check(table_descriptor, TTableDescriptor)
return self.executor.call(
lambda: self.client.modifyTable(table_descriptor))
def modify_columnFamily(self, table_name, desc):
"""
Args:
table_name:
desc:
Returns:
"""
type_check(desc, TColumnFamilyDescriptor)
tn = str_to_tablename(table_name)
return self.executor.call(
lambda: self.client.modifyColumnFamily(tn, desc))
def create_table(self, desc, split_keys):
"""
Args:
desc: TTableDescriptor, which contains the meta information of the table to create.
split_keys: split keys for table pre-split.
Returns: True if success, else False.
"""
type_check(desc, TTableDescriptor)
type_check(split_keys, list)
return self.executor.call(
lambda: self.client.createTable(desc, split_keys))
def scan(self, scan):
# type: (Scan) -> List[Cell]
"""
Send a Scan request to the thrift server.
Args:
scan: A single Scan object.
Returns:If success: a list of cells.
If success but not matched data: an empty list.
If the start row do not exists, it will raise an IllegalArgument error.
If scan failed: False.
"""
type_check(scan, Scan)
return self._results_format(self._client._scan(table_name=self.name, scan=scan))
def get_user_permissions(self, domain_name):
"""
Args:
domain_name:
scope:
Returns:
"""
type_check(domain_name, str)
scope = TPermissionScope.TABLE if domain_name[
0] != '@' else TPermissionScope.NAMESPACE
return self.executor.call(
lambda: self.client.getUserPermission(domain_name, scope))
def get(self, get):
# type: (Get) -> List[Cell]
"""
Send a single Get operation to the thrift server.
Args:
get: A customized Get object.
Returns: If success: a list of cells.
If success but not matched data: an empty list.
If get failed: False.
"""
type_check(get, Get)
result = self._client._get_row(table_name=self.name, get=get)
# if result is False, that means the operation failed after retry N times.
# if result is [], that means there is no matched cell in hbase.
if not result:
return []
return self._results_format(result)
def get_columnDescriptor(self, table_name, cf):
"""
Return a column descriptor for specific table with the given cf name.
Args:
table_name:
cf:
Returns:
"""
type_check(cf, str)
td = self.get_tableDescriptor(table_name)
check_none(td, "Unknown table.")
for col in td.columns:
if to_str(col.name) == cf:
return col
raise RuntimeError(
"The table does not contain a column family with name {}".format(
cf))
def delete_batch(self, batch):
# type: (List[Delete]) -> bool
"""
Send a list of Delete requests to the thrift server.
The requests will be sent batch by batch.
The logger will log the failed position if one batch of requests failed.
Args:
batch: a list of Delete objects.
Returns: True if successes, False otherwise.
"""
type_check(batch, (list, tuple))
for delete in batch:
type_check(delete, Delete)
for i in range(0, len(batch), self.conf.batch_size):
if not self._client._delete_batch(table_name=self.name,
deletes=batch[i: i + self.conf.batch_size]):
logger.error("Delete_batch failed at index {}, the delete requests after {} (inclusive) are not sent.".format(i, i))
return False
return True
def put_batch(self, puts):
# type: (List[Put]) -> bool
"""
Send multiple Put requests to the server at one time.
The requests will be sent batch by batch.
The logger will log the failed position if one batch of requests failed.
Args:
puts: A list of Put objects
Returns: True if successes, False otherwise.
"""
type_check(puts, list)
for put in puts:
type_check(put, Put)
for i in range(0, len(puts), self.conf.batch_size):
result = self._client._put_rows(table_name=self.name, puts=puts[i: i + self.conf.batch_size])
if not result:
logger.error("An error occurs at index {}, the Put requests after {} (inclusive) failed.".format(i, i))
return False
return True
def copy_from_exist(self, desc):
type_check(desc, TColumnFamilyDescriptor)
self.name = desc.name
self.attributes = desc.attributes
self.configuration = desc.configuration
self.blockSize = desc.blockSize
self.bloomnFilterType = desc.bloomnFilterType
self.compressionType = desc.compressionType
self.dfsReplication = desc.dfsReplication
self.dataBlockEncoding = desc.dataBlockEncoding
self.keepDeletedCells = desc.keepDeletedCells
self.maxVersions = desc.maxVersions
self.minVersions = desc.minVersions
self.scope = desc.scope
self.timeToLive = desc.timeToLive
self.blockCacheEnabled = desc.blockCacheEnabled if desc.blockCacheEnabled else None
self.cacheBloomsOnWrite = desc.cacheBloomsOnWrite if desc.cacheBloomsOnWrite else None
self.cacheDataOnWrite = desc.cacheDataOnWrite if desc.cacheDataOnWrite else None
self.cacheIndexesOnWrite = desc.cacheIndexesOnWrite if desc.cacheIndexesOnWrite else None
self.compressTags = desc.compressTags if desc.compressTags else None
self.evictBlocksOnClose = desc.evictBlocksOnClose
self.inMemory = desc.inMemory if desc.inMemory else None
def __init__(self, name=None):
type_check(name, str)
self.name = name
self.attributes = {}
self.configuration = {}
self.blockSize = None
self.bloomnFilterType = None
self.compressionType = None
self.dfsReplication = None
self.dataBlockEncoding = None
self.keepDeletedCells = None
self.maxVersions = None
self.minVersions = None
self.scope = None
self.timeToLive = None
self.blockCacheEnabled = None
self.cacheBloomsOnWrite = None
self.cacheDataOnWrite = None
self.cacheIndexesOnWrite = None
self.compressTags = None
self.evictBlocksOnClose = None
self.inMemory = None
def set_blockSize(self, bs):
type_check(bs, int)
if bs < 1:
raise RuntimeError("Illegal block size " + bs)
self.blockSize = bs
return self
def set_keepDeletedCells(self, kdc):
type_check(kdc, bool)
self.keepDeletedCells = kdc
return self
def set_inMemory(self, value):
type_check(value, bool)
self.inMemory = value
return self
def set_evictBlocksOnClose(self, value):
type_check(value, bool)
self.evictBlocksOnClose = value
return self
def set_compressTags(self, value):
type_check(value, bool)
self.compressTags = value
return self
def set_cacheDataOnWrite(self, value):
type_check(value, bool)
self.cacheBloomsOnWrite = value
return self
def set_blockCacheEnabled(self, enabled):
type_check(enabled, bool)
self.blockCacheEnabled = enabled
return self
def set_timeToLive(self, ttl):
type_check(ttl, int)
if ttl < 1:
raise RuntimeError("Illegal TTL value {}".format(ttl))
self.timeToLive = ttl
return self
def copy_from_exist(self, desc):
type_check(desc, TTableDescriptor)
self.name = ':'.join(
[to_str(desc.tableName.ns),
to_str(desc.tableName.qualifier)])
self.columns = desc.columns
def set_dfsReplication(self, hr):
type_check(hr, int)
if hr < 1:
raise RuntimeError(
"Illegal number of dfs replication {}".format(hr))
self.dfsReplication = hr
def set_cacheIndexesOnWrite(self, value):
type_check(value, bool)
self.cacheIndexesOnWrite = value
return self
def set_minVersions(self, mv):
type_check(mv, int)
if mv < 0:
raise RuntimeError("Illegal min versions number {}".format(mv))
self.minVersions = mv
return self
