def tearDown(self):
try:
get_table = GetTableRequest().set_table_name(table_name)
result = self.handle.get_table(get_table)
result.wait_for_completion(self.handle, wait_timeout, 1000)
drop_request = TableRequest().set_statement(self.drop_tb_statement)
self._do_table_request(drop_request)
except TableNotFoundException:
pass
finally:
self.tear_down()
def main():
handle = None
try:
#
# Create a handle
#
handle = get_handle(tenant_id)
#
# List any existing tables for this tenant
#
print('Listing tables')
ltr = ListTablesRequest()
lr_result = handle.list_tables(ltr)
print('Existing tables: ' + str(lr_result))
#
# Create a table
#
statement = 'Create table if not exists ' + table_name + '(id integer, \
sid integer, name string, primary key(shard(sid), id))'
print('Creating table: ' + statement)
request = TableRequest().set_statement(statement).set_table_limits(
TableLimits(30, 10, 1))
result = handle.table_request(request)
#
# Table creation can take time, depending on the state of the system.
# If if fails after 40s, re-run the program
#
result.wait_for_state(handle, table_name, State.ACTIVE, 40000, 3000)
print('After create table')
#
# Create an index
#
statement = ('Create index if not exists ' + index_name + ' on ' +
table_name + '(name)')
print('Creating index: ' + statement)
request = TableRequest().set_statement(statement)
result = handle.table_request(request)
#
# Index creation can take time, depending on the state of the system.
# If if fails after 40s, re-run the program
#
result.wait_for_state(handle, table_name, State.ACTIVE, 40000, 3000)
print('After create index')
#
# Get the table
#
request = GetTableRequest().set_table_name(table_name)
result = handle.get_table(request)
print('After get table: ' + str(result))
#
# Get the indexes
#
request = GetIndexesRequest().set_table_name(table_name)
result = handle.get_indexes(request)
print('The indexes for: ' + table_name)
for idx in result.get_indexes():
print('\t' + str(idx))
#
# Get the table usage information
#
request = TableUsageRequest().set_table_name(table_name)
result = handle.get_table_usage(request)
print('The table usage information for: ' + table_name)
for record in result.get_usage_records():
print('\t' + str(record))
#
# Drop the table
#
if drop_table:
request = TableRequest().set_statement('drop table if exists ' +
table_name)
result = handle.table_request(request)
#
# Table drop can take time, depending on the state of the system.
# If this wait fails the table will still probably been dropped
#
result.wait_for_state(handle, table_name, State.DROPPED, 30000,
2000)
print('After drop table')
else:
print('Not dropping table')
print('Example is complete')
except Exception as e:
print(e)
traceback.print_exc()
finally:
# If the handle isn't closed Python will not exit properly
if handle is not None:
handle.close()
def setUp(self):
self.set_up()
self.get_table_request = GetTableRequest().set_timeout(timeout)
class TestGetTable(unittest.TestCase, TestBase):
@classmethod
def setUpClass(cls):
cls.set_up_class()
create_statement = ('CREATE TABLE ' + table_name +
'(fld_id INTEGER, fld_long LONG, \
fld_float FLOAT, fld_double DOUBLE, fld_bool BOOLEAN, fld_str STRING, \
fld_bin BINARY, fld_time TIMESTAMP(1), fld_num NUMBER, fld_json JSON, \
fld_arr ARRAY(STRING), fld_map MAP(STRING), \
fld_rec RECORD(fld_id LONG, fld_bool BOOLEAN, fld_str STRING), \
PRIMARY KEY(fld_id)) USING TTL 30 DAYS')
global table_limits
table_limits = TableLimits(100, 100, 1)
create_request = TableRequest().set_statement(
create_statement).set_table_limits(table_limits)
cls.table_request(create_request)
@classmethod
def tearDownClass(cls):
cls.tear_down_class()
def setUp(self):
self.set_up()
self.get_table_request = GetTableRequest().set_timeout(timeout)
def tearDown(self):
self.tear_down()
def testGetTableSetIllegalTableName(self):
self.assertRaises(IllegalArgumentException,
self.get_table_request.set_table_name,
{'name': table_name})
self.get_table_request.set_table_name('IllegalTable')
self.assertRaises(TableNotFoundException, self.handle.get_table,
self.get_table_request)
def testGetTableSetIllegalCompartment(self):
self.assertRaises(IllegalArgumentException,
self.get_table_request.set_compartment, {})
self.assertRaises(IllegalArgumentException,
self.get_table_request.set_compartment, '')
def testGetTableSetIllegalOperationId(self):
self.assertRaises(IllegalArgumentException,
self.get_table_request.set_operation_id, 0)
def testGetTableSetIllegalTimeout(self):
self.assertRaises(IllegalArgumentException,
self.get_table_request.set_timeout, 'IllegalTimeout')
self.assertRaises(IllegalArgumentException,
self.get_table_request.set_timeout, 0)
self.assertRaises(IllegalArgumentException,
self.get_table_request.set_timeout, -1)
def testGetTableNoTableName(self):
self.assertRaises(IllegalArgumentException, self.handle.get_table,
self.get_table_request)
def testGetTableGets(self):
self.get_table_request.set_table_name(table_name)
self.assertEqual(self.get_table_request.get_table_name(), table_name)
self.assertIsNone(self.get_table_request.get_compartment())
self.assertIsNone(self.get_table_request.get_operation_id())
def testGetTableIllegalRequest(self):
self.assertRaises(IllegalArgumentException, self.handle.get_table,
'IllegalRequest')
def testGetTableNormal(self):
self.get_table_request.set_table_name(table_name)
result = self.handle.get_table(self.get_table_request)
if is_minicloud() or is_pod():
self.check_table_result(result, State.ACTIVE, table_limits)
else:
self.check_table_result(result,
State.ACTIVE,
table_limits,
has_operation_id=False)
def testGetTableWithOperationId(self):
drop_request = TableRequest().set_statement('DROP TABLE IF EXISTS ' +
table_name)
table_result = self.handle.table_request(drop_request)
self.get_table_request.set_table_name(table_name).set_operation_id(
table_result.get_operation_id())
result = self.handle.get_table(self.get_table_request)
if is_minicloud() or is_pod():
self.check_table_result(result, [State.DROPPING, State.DROPPED],
table_limits)
else:
self.check_table_result(result, [State.DROPPING, State.DROPPED])
table_result.wait_for_completion(self.handle, wait_timeout, 1000)
def main():
handle = None
try:
#
# Create a handle
#
handle = get_handle(tenant_id)
#
# List any existing tables for this tenant
#
print('Listing tables')
ltr = ListTablesRequest()
lr_result = handle.list_tables(ltr)
print('Existing tables: ' + str(lr_result))
#
# Create a table
#
statement = 'Create table if not exists ' + table_name + '(id integer, \
sid integer, name string, primary key(shard(sid), id))'
print('Creating table: ' + statement)
request = TableRequest().set_statement(statement).set_table_limits(
TableLimits(30, 10, 1))
handle.do_table_request(request, 40000, 3000)
print('After create table')
#
# Create an index
#
statement = ('Create index if not exists ' + index_name + ' on ' +
table_name + '(name)')
print('Creating index: ' + statement)
request = TableRequest().set_statement(statement)
handle.do_table_request(request, 40000, 3000)
print('After create index')
#
# Get the table
#
request = GetTableRequest().set_table_name(table_name)
result = handle.get_table(request)
print('After get table: ' + str(result))
#
# Get the indexes
#
request = GetIndexesRequest().set_table_name(table_name)
result = handle.get_indexes(request)
print('The indexes for: ' + table_name)
for idx in result.get_indexes():
print('\t' + str(idx))
#
# Get the table usage information, on-prem mode not supported
#
if not using_on_prem:
request = TableUsageRequest().set_table_name(table_name)
result = handle.get_table_usage(request)
print('The table usage information for: ' + table_name)
for record in result.get_usage_records():
print('\t' + str(record))
#
# Drop the index
#
request = TableRequest().set_statement(
'drop index ' + index_name + ' on ' + table_name)
handle.do_table_request(request, 30000, 2000)
print('After drop index')
#
# Drop the table
#
if drop_table:
request = TableRequest().set_statement(
'drop table if exists ' + table_name)
handle.do_table_request(request, 30000, 2000)
print('After drop table')
else:
print('Not dropping table')
print('Example is complete')
except Exception as e:
print(e)
traceback.print_exc()
finally:
# If the handle isn't closed Python will not exit properly
if handle is not None:
handle.close()
class TestGetTable(unittest.TestCase, TestBase):
@classmethod
def setUpClass(cls):
TestBase.set_up_class()
create_statement = (
'CREATE TABLE ' + table_name + '(fld_id INTEGER, fld_long LONG, \
fld_float FLOAT, fld_double DOUBLE, fld_bool BOOLEAN, fld_str STRING, \
fld_bin BINARY, fld_time TIMESTAMP(1), fld_num NUMBER, fld_json JSON, \
fld_arr ARRAY(STRING), fld_map MAP(STRING), \
fld_rec RECORD(fld_id LONG, fld_bool BOOLEAN, fld_str STRING), \
PRIMARY KEY(fld_id)) USING TTL 30 DAYS')
global table_limits
table_limits = TableLimits(5000, 5000, 50)
create_request = TableRequest().set_statement(
create_statement).set_table_limits(table_limits)
cls._result = TestBase.table_request(create_request, State.ACTIVE)
@classmethod
def tearDownClass(cls):
TestBase.tear_down_class()
def setUp(self):
TestBase.set_up(self)
self.get_table_request = GetTableRequest().set_timeout(timeout)
def tearDown(self):
TestBase.tear_down(self)
def testGetTableSetIllegalTableName(self):
self.assertRaises(IllegalArgumentException,
self.get_table_request.set_table_name,
{'name': table_name})
self.get_table_request.set_table_name('IllegalTable')
self.assertRaises(TableNotFoundException, self.handle.get_table,
self.get_table_request)
def testGetTableSetIllegalOperationId(self):
self.assertRaises(IllegalArgumentException,
self.get_table_request.set_operation_id, 0)
def testGetTableSetIllegalTimeout(self):
self.assertRaises(IllegalArgumentException,
self.get_table_request.set_timeout, 'IllegalTimeout')
self.assertRaises(IllegalArgumentException,
self.get_table_request.set_timeout, 0)
self.assertRaises(IllegalArgumentException,
self.get_table_request.set_timeout, -1)
def testGetTableNoTableName(self):
self.assertRaises(IllegalArgumentException, self.handle.get_table,
self.get_table_request)
def testGetTableGets(self):
self.get_table_request.set_table_name(table_name)
self.assertEqual(self.get_table_request.get_table_name(), table_name)
self.assertIsNone(self.get_table_request.get_operation_id())
def testGetTableIllegalRequest(self):
self.assertRaises(IllegalArgumentException, self.handle.get_table,
'IllegalRequest')
def testGetTableNormal(self):
self.get_table_request.set_table_name(table_name)
result = self.handle.get_table(self.get_table_request)
self.assertEqual(result.get_table_name(), table_name)
self.assertEqual(result.get_state(), State.ACTIVE)
self.assertEqual(result.get_table_limits().get_read_units(),
table_limits.get_read_units())
self.assertEqual(result.get_table_limits().get_write_units(),
table_limits.get_write_units())
self.assertEqual(result.get_table_limits().get_storage_gb(),
table_limits.get_storage_gb())
if not_cloudsim():
self.assertIsNotNone(result.get_schema())
self.assertIsNone(result.get_operation_id())
def testGetTableWithOperationId(self):
drop_request = TableRequest().set_statement(
'DROP TABLE IF EXISTS ' + table_name)
table_result = self.handle.table_request(drop_request)
self.get_table_request.set_table_name(table_name).set_operation_id(
table_result.get_operation_id())
result = self.handle.get_table(self.get_table_request)
self.assertEqual(result.get_table_name(), table_name)
self.assertEqual(result.get_state(), State.DROPPING)
self.assertEqual(result.get_table_limits().get_read_units(),
table_limits.get_read_units())
self.assertEqual(result.get_table_limits().get_write_units(),
table_limits.get_write_units())
self.assertEqual(result.get_table_limits().get_storage_gb(),
table_limits.get_storage_gb())
if not_cloudsim():
self.assertIsNotNone(result.get_schema())
table_result.wait_for_state(self.handle, table_name, State.DROPPED,
wait_timeout, 1000)