def testTableRequestModifyTableLimits(self): # create table before modifying the table limits request = TableRequest().set_statement( self.create_tb_statement).set_table_limits(self.table_limits) result = self.handle.table_request(request) result.wait_for_state(self.handle, table_name, State.ACTIVE, wait_timeout, 1000) # modify the table limits table_limits = TableLimits(10000, 10000, 100) self.table_request.set_table_name(table_name).set_table_limits( table_limits) result = self.handle.table_request(self.table_request) self.assertEqual(result.get_table_name(), table_name) self.assertEqual(result.get_state(), State.UPDATING) if not_cloudsim(): self.assertIsNotNone(result.get_schema()) wait_result = result.wait_for_state(self.handle, table_name, State.ACTIVE, wait_timeout, 1000) self.assertEqual(wait_result.get_table_name(), table_name) self.assertEqual(wait_result.get_state(), State.ACTIVE) self.assertEqual(wait_result.get_table_limits().get_read_units(), table_limits.get_read_units()) self.assertEqual(wait_result.get_table_limits().get_write_units(), table_limits.get_write_units()) self.assertEqual(wait_result.get_table_limits().get_storage_gb(), table_limits.get_storage_gb()) if not_cloudsim(): self.assertIsNotNone(wait_result.get_schema()) self.assertIsNone(wait_result.get_operation_id()) # drop table after modifying the table limits request.set_statement(self.drop_tb_statement) result = self.handle.table_request(request) result.wait_for_state(self.handle, table_name, State.DROPPED, wait_timeout, 1000)
def testTableRequestAlterTableTTL(self): # create table before altering table request = TableRequest().set_statement( self.create_tb_statement).set_table_limits(self.table_limits) self._do_table_request(request) # alter table ttl self.table_request.set_statement(self.alter_ttl_statement) result = self.handle.table_request(self.table_request) self.check_table_result(result, State.UPDATING, self.table_limits) self._wait_for_completion(result) self.check_table_result(result, State.ACTIVE, self.table_limits) # drop table after altering table request.set_statement(self.drop_tb_statement) self._do_table_request(request)
def testTableRequestAlterTable(self): # create table before altering table request = TableRequest().set_statement( self.create_tb_statement).set_table_limits(self.table_limits) self._do_table_request(request) # alter table failed with TableLimits set if not is_onprem(): request.set_statement(self.alter_fld_statement) self.assertRaises(IllegalArgumentException, self.handle.table_request, request) # alter table succeed without TableLimits set self.table_request.set_statement(self.alter_fld_statement) result = self.handle.table_request(self.table_request) self.check_table_result(result, State.UPDATING, self.table_limits) self._wait_for_completion(result) self.check_table_result(result, State.ACTIVE, self.table_limits) # drop table after altering table request.set_statement(self.drop_tb_statement) self._do_table_request(request)
def testTableRequestAlterTable(self): # create table before altering table request = TableRequest().set_statement( self.create_tb_statement).set_table_limits(self.table_limits) result = self.handle.table_request(request) result.wait_for_state(self.handle, table_name, State.ACTIVE, wait_timeout, 1000) # alter table failed with TableLimits set request.set_statement(self.alter_fld_statement) self.assertRaises(IllegalArgumentException, self.handle.table_request, request) # alter table succeed without TableLimits set self.table_request.set_statement(self.alter_fld_statement) result = self.handle.table_request(self.table_request) self.assertEqual(result.get_table_name(), table_name) self.assertEqual(result.get_state(), State.UPDATING) self.assertEqual(result.get_table_limits().get_read_units(), self.table_limits.get_read_units()) self.assertEqual(result.get_table_limits().get_write_units(), self.table_limits.get_write_units()) self.assertEqual(result.get_table_limits().get_storage_gb(), self.table_limits.get_storage_gb()) if not_cloudsim(): self.assertIsNotNone(result.get_schema()) wait_result = result.wait_for_state(self.handle, table_name, State.ACTIVE, wait_timeout, 1000) self.assertEqual(wait_result.get_table_name(), table_name) self.assertEqual(wait_result.get_state(), State.ACTIVE) self.assertEqual(wait_result.get_table_limits().get_read_units(), self.table_limits.get_read_units()) self.assertEqual(wait_result.get_table_limits().get_write_units(), self.table_limits.get_write_units()) self.assertEqual(wait_result.get_table_limits().get_storage_gb(), self.table_limits.get_storage_gb()) if not_cloudsim(): self.assertIsNotNone(wait_result.get_schema()) self.assertIsNone(wait_result.get_operation_id()) # drop table after altering table request.set_statement(self.drop_tb_statement) result = self.handle.table_request(request) result.wait_for_state(self.handle, table_name, State.DROPPED, wait_timeout, 1000)
def testTableRequestAlterTableTTL(self): # create table before altering table request = TableRequest().set_statement( self.create_tb_statement).set_table_limits(self.table_limits) result = self.handle.table_request(request) result.wait_for_state(self.handle, table_name, State.ACTIVE, wait_timeout, 1000) # alter table ttl self.table_request.set_statement(self.alter_ttl_statement) result = self.handle.table_request(self.table_request) self.assertEqual(result.get_table_name(), table_name) self.assertEqual(result.get_state(), State.UPDATING) self.assertEqual(result.get_table_limits().get_read_units(), self.table_limits.get_read_units()) self.assertEqual(result.get_table_limits().get_write_units(), self.table_limits.get_write_units()) self.assertEqual(result.get_table_limits().get_storage_gb(), self.table_limits.get_storage_gb()) if not_cloudsim(): self.assertIsNotNone(result.get_schema()) wait_result = result.wait_for_state(self.handle, table_name, State.ACTIVE, wait_timeout, 1000) self.assertEqual(wait_result.get_table_name(), table_name) self.assertEqual(wait_result.get_state(), State.ACTIVE) self.assertEqual(wait_result.get_table_limits().get_read_units(), self.table_limits.get_read_units()) self.assertEqual(wait_result.get_table_limits().get_write_units(), self.table_limits.get_write_units()) self.assertEqual(wait_result.get_table_limits().get_storage_gb(), self.table_limits.get_storage_gb()) if not_cloudsim(): self.assertIsNotNone(wait_result.get_schema()) self.assertIsNone(wait_result.get_operation_id()) # drop table after altering table request.set_statement(self.drop_tb_statement) result = self.handle.table_request(request) result.wait_for_state(self.handle, table_name, State.DROPPED, wait_timeout, 1000)
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(3), 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 1 HOURS') limits = TableLimits(100, 100, 1) create_request = TableRequest().set_statement( create_statement).set_table_limits(limits) cls.table_request(create_request) create_idx_request = TableRequest() create_idx_statement = ('CREATE INDEX ' + index_name + '1 ON ' + table_name + '(fld_str)') create_idx_request.set_statement(create_idx_statement) cls.table_request(create_idx_request) create_idx_statement = ('CREATE INDEX ' + index_name + '2 ON ' + table_name + '(fld_map.values())') create_idx_request.set_statement(create_idx_statement) cls.table_request(create_idx_request)
def testTableRequestModifyTableLimits(self): # create table before modifying the table limits request = TableRequest().set_statement( self.create_tb_statement).set_table_limits(self.table_limits) self._do_table_request(request) # modify the table limits table_limits = TableLimits(50, 50, 1) self.table_request.set_table_name(table_name).set_table_limits( table_limits) if is_onprem(): self.assertRaises(OperationNotSupportedException, self.handle.table_request, self.table_request) return result = self.handle.table_request(self.table_request) self.check_table_result(result, State.UPDATING, check_limit=False, check_schema=False) result.wait_for_completion(self.handle, wait_timeout, 1000) self.check_table_result(result, State.ACTIVE, table_limits) # drop table after modifying the table limits request.set_statement(self.drop_tb_statement) self._do_table_request(request)
def testTableRequestModifyTableLimits(self): # create table before modifying the table limits request = TableRequest().set_statement( self.create_tb_statement).set_table_limits(self.table_limits) self._do_table_request(request) # modify the table limits table_limits = TableLimits(10000, 10000, 100) self.table_request.set_table_name(table_name).set_table_limits( table_limits) if is_onprem(): self.assertRaises(OperationNotSupportedException, self.handle.table_request, self.table_request) return result = self.handle.table_request(self.table_request) self.assertEqual(result.get_table_name(), table_name) self.assertEqual(result.get_state(), State.UPDATING) if not_cloudsim(): self.assertIsNotNone(result.get_schema()) self.assertIsNotNone(result.get_operation_id()) self._wait_for_completion(result) self.check_table_result(result, State.ACTIVE, table_limits) # drop table after modifying the table limits request.set_statement(self.drop_tb_statement) self._do_table_request(request)
def setUpClass(cls): cls.set_up_class() index_name = 'idx_' + table_name create_statement = ( 'CREATE TABLE ' + table_name + '(fld_sid INTEGER, fld_id INTEGER, \ fld_long LONG, fld_float FLOAT, fld_double DOUBLE, fld_bool BOOLEAN, \ fld_str STRING, fld_bin BINARY, fld_time TIMESTAMP(6), 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(SHARD(fld_sid), fld_id))') limits = TableLimits(100, 100, 1) create_request = TableRequest().set_statement( create_statement).set_table_limits(limits) cls.table_request(create_request) if (version is not None and (is_cloudsim() and compare_version(version, '1.4.0') == -1 or is_onprem() and compare_version(version, '20.2.0') == -1)): create_idx_request = TableRequest() create_idx_statement = ( 'CREATE INDEX ' + index_name + '1 ON ' + table_name + '(fld_long)') create_idx_request.set_statement(create_idx_statement) cls.table_request(create_idx_request) create_idx_statement = ( 'CREATE INDEX ' + index_name + '2 ON ' + table_name + '(fld_str)') create_idx_request.set_statement(create_idx_statement) cls.table_request(create_idx_request) create_idx_statement = ( 'CREATE INDEX ' + index_name + '3 ON ' + table_name + '(fld_bool)') create_idx_request.set_statement(create_idx_statement) cls.table_request(create_idx_request) create_idx_statement = ( 'CREATE INDEX ' + index_name + '4 ON ' + table_name + '(fld_json.location as point)') create_idx_request.set_statement(create_idx_statement) cls.table_request(create_idx_request) global query_statement query_statement = ('SELECT fld_sid, fld_id FROM ' + table_name + ' WHERE fld_sid = 1')
def setUpClass(cls): cls.set_up_class() index_name = 'idx_' + table_name create_statement = ('CREATE TABLE ' + table_name + '(fld_sid INTEGER, fld_id INTEGER, \ fld_long LONG, fld_float FLOAT, fld_double DOUBLE, fld_bool BOOLEAN, \ fld_str STRING, fld_bin BINARY, fld_time TIMESTAMP(6), 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(SHARD(fld_sid), fld_id))') limits = TableLimits(5000, 5000, 50) create_request = TableRequest().set_statement( create_statement).set_table_limits(limits) cls.table_request(create_request) create_idx_request = TableRequest() create_idx_statement = ('CREATE INDEX ' + index_name + '1 ON ' + table_name + '(fld_long)') create_idx_request.set_statement(create_idx_statement) cls.table_request(create_idx_request) create_idx_statement = ('CREATE INDEX ' + index_name + '2 ON ' + table_name + '(fld_str)') create_idx_request.set_statement(create_idx_statement) cls.table_request(create_idx_request) create_idx_statement = ('CREATE INDEX ' + index_name + '3 ON ' + table_name + '(fld_bool)') create_idx_request.set_statement(create_idx_statement) cls.table_request(create_idx_request) if test_advanced_query(): create_idx_statement = ('CREATE INDEX ' + index_name + '4 ON ' + table_name + '(fld_json.location as point)') create_idx_request.set_statement(create_idx_statement) cls.table_request(create_idx_request) global prepare_cost prepare_cost = 2 global query_statement query_statement = ('SELECT fld_sid, fld_id FROM ' + table_name + ' WHERE fld_sid = 1')
from borneo import NoSQLHandleConfig, NoSQLHandle, Regions from borneo import TableRequest # create and close AuthorizationProvider at_provider = SignatureProvider(config_file='~/.oci/config') at_provider.close() # create handle config using a desired region as endpoint and set a # default compartment. handle_config = NoSQLHandleConfig(Regions.SA_SAOPAULO_1) handle_config.set_authorization_provider(at_provider) handle_config.set_default_compartment('<your-compartment-id>') # create the handle. nosql_handle = NoSQLHandle(handle_config) table_ddl = """ DROP TABLE produtos """ # creates a request object that contains the DLL instruction. table_request = TableRequest() table_request.set_statement(table_ddl) # execute the DDL instruction. nosql_handle.table_request(table_request) # free up the resources from handle. nosql_handle.close()
class TestTableRequest(unittest.TestCase, TestBase): @classmethod def setUpClass(cls): TestBase.set_up_class() @classmethod def tearDownClass(cls): TestBase.tear_down_class() def setUp(self): TestBase.set_up(self) self.handle_config = get_handle_config(tenant_id) index_name = 'idx_' + table_name self.create_tb_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(4), 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') self.create_idx_statement = ( 'CREATE INDEX ' + index_name + ' ON ' + table_name + '(fld_str, fld_double)') self.alter_fld_statement = ( 'ALTER TABLE ' + table_name + '(DROP fld_num)') self.alter_ttl_statement = ( 'ALTER TABLE ' + table_name + ' USING TTL 16 HOURS') self.drop_idx_statement = ( 'DROP INDEX ' + index_name + ' ON ' + table_name) self.drop_tb_statement = ('DROP TABLE IF EXISTS ' + table_name) self.table_request = TableRequest() self.table_limits = TableLimits(5000, 5000, 50) def tearDown(self): try: TableResult.wait_for_state(self.handle, table_name, State.ACTIVE, wait_timeout, 1000) drop_request = TableRequest().set_statement(self.drop_tb_statement) result = self.handle.table_request(drop_request) result.wait_for_state(self.handle, table_name, State.DROPPED, wait_timeout, 1000) except TableNotFoundException: pass finally: TestBase.tear_down(self) def testTableRequestSetIllegalStatement(self): self.table_request.set_statement('IllegalStatement') self.assertRaises(IllegalArgumentException, self.handle.table_request, self.table_request) self.table_request.set_statement( 'ALTER TABLE IllegalTable (DROP fld_num)') self.assertRaises(TableNotFoundException, self.handle.table_request, self.table_request) def testTableRequestSetIllegalTableLimits(self): self.assertRaises(IllegalArgumentException, self.table_request.set_table_limits, 'IllegalTableLimits') self.assertRaises(IllegalArgumentException, self.table_request.set_table_limits, None) self.table_request.set_statement( self.create_tb_statement).set_table_limits(TableLimits(5000, 0, 50)) self.assertRaises(IllegalArgumentException, self.handle.table_request, self.table_request) def testTableRequestSetIllegalTableName(self): self.assertRaises(IllegalArgumentException, self.table_request.set_table_name, {'name': table_name}) self.table_request.set_table_name( 'IllegalTable').set_table_limits(self.table_limits) self.assertRaises(TableNotFoundException, self.handle.table_request, self.table_request) def testTableRequestSetIllegalTimeout(self): self.assertRaises(IllegalArgumentException, self.table_request.set_timeout, 'IllegalTimeout') self.assertRaises(IllegalArgumentException, self.table_request.set_timeout, 0) self.assertRaises(IllegalArgumentException, self.table_request.set_timeout, -1) def testTableRequestSetIllegalDefaults(self): self.assertRaises(IllegalArgumentException, self.table_request.set_defaults, 'IllegalDefaults') def testTableRequestSetDefaults(self): self.table_request.set_defaults(self.handle_config) self.assertEqual(self.table_request.get_timeout(), table_request_timeout) def testTableRequestNoStatementAndTableName(self): self.assertRaises(IllegalArgumentException, self.handle.table_request, self.table_request) def testTableRequestBothStatementAndTableName(self): self.table_request.set_statement( self.create_tb_statement).set_table_name(table_name) self.assertRaises(IllegalArgumentException, self.handle.table_request, self.table_request) def testTableRequestOnlyTableName(self): self.table_request.set_table_name(table_name) self.assertRaises(IllegalArgumentException, self.handle.table_request, self.table_request) def testTableRequestGets(self): self.table_request.set_table_name(table_name).set_statement( self.create_tb_statement).set_table_limits(self.table_limits) self.assertEqual(self.table_request.get_statement(), self.create_tb_statement) self.assertEqual(self.table_request.get_table_limits(), self.table_limits) self.assertEqual(self.table_request.get_table_name(), table_name) def testTableRequestIllegalRequest(self): self.assertRaises(IllegalArgumentException, self.handle.table_request, 'IllegalRequest') def testTableRequestCreateDropTable(self): # create table failed without TableLimits set self.table_request.set_statement(self.create_tb_statement) self.assertRaises(IllegalArgumentException, self.handle.table_request, self.table_request) # create table succeed with TableLimits set self.table_request.set_table_limits(self.table_limits) result = self.handle.table_request(self.table_request) self.assertEqual(result.get_table_name(), table_name) self.assertEqual(result.get_state(), State.CREATING) self.assertEqual(result.get_table_limits().get_read_units(), self.table_limits.get_read_units()) self.assertEqual(result.get_table_limits().get_write_units(), self.table_limits.get_write_units()) self.assertEqual(result.get_table_limits().get_storage_gb(), self.table_limits.get_storage_gb()) if not_cloudsim(): self.assertIsNone(result.get_schema()) wait_result = result.wait_for_state(self.handle, table_name, State.ACTIVE, wait_timeout, 1000) self.assertEqual(wait_result.get_table_name(), table_name) self.assertEqual(wait_result.get_state(), State.ACTIVE) self.assertEqual(wait_result.get_table_limits().get_read_units(), self.table_limits.get_read_units()) self.assertEqual(wait_result.get_table_limits().get_write_units(), self.table_limits.get_write_units()) self.assertEqual(wait_result.get_table_limits().get_storage_gb(), self.table_limits.get_storage_gb()) if not_cloudsim(): self.assertIsNotNone(wait_result.get_schema()) self.assertIsNone(wait_result.get_operation_id()) # drop table by resetting the statement self.table_request.set_statement(self.drop_tb_statement) result = self.handle.table_request(self.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(), self.table_limits.get_read_units()) self.assertEqual(result.get_table_limits().get_write_units(), self.table_limits.get_write_units()) self.assertEqual(result.get_table_limits().get_storage_gb(), self.table_limits.get_storage_gb()) if not_cloudsim(): self.assertIsNotNone(wait_result.get_schema()) wait_result = result.wait_for_state(self.handle, table_name, State.DROPPED, wait_timeout, 1000) self.assertEqual(wait_result.get_table_name(), table_name) self.assertEqual(wait_result.get_state(), State.DROPPED) self.assertEqual(wait_result.get_table_limits().get_read_units(), self.table_limits.get_read_units()) self.assertEqual(wait_result.get_table_limits().get_write_units(), self.table_limits.get_write_units()) self.assertEqual(wait_result.get_table_limits().get_storage_gb(), self.table_limits.get_storage_gb()) if not_cloudsim(): self.assertIsNone(wait_result.get_schema()) self.assertIsNone(wait_result.get_operation_id()) def testTableRequestCreateDropIndex(self): # create table before creating index request = TableRequest().set_statement( self.create_tb_statement).set_table_limits(self.table_limits) result = self.handle.table_request(request) result.wait_for_state(self.handle, table_name, State.ACTIVE, wait_timeout, 1000) # create index by resetting the statement self.table_request.set_statement(self.create_idx_statement) result = self.handle.table_request(self.table_request) self.assertEqual(result.get_table_name(), table_name) self.assertEqual(result.get_state(), State.UPDATING) self.assertEqual(result.get_table_limits().get_read_units(), self.table_limits.get_read_units()) self.assertEqual(result.get_table_limits().get_write_units(), self.table_limits.get_write_units()) self.assertEqual(result.get_table_limits().get_storage_gb(), self.table_limits.get_storage_gb()) if not_cloudsim(): self.assertIsNotNone(result.get_schema()) wait_result = result.wait_for_state(self.handle, table_name, State.ACTIVE, wait_timeout, 1000) self.assertEqual(wait_result.get_table_name(), table_name) self.assertEqual(wait_result.get_state(), State.ACTIVE) self.assertEqual(wait_result.get_table_limits().get_read_units(), self.table_limits.get_read_units()) self.assertEqual(wait_result.get_table_limits().get_write_units(), self.table_limits.get_write_units()) self.assertEqual(wait_result.get_table_limits().get_storage_gb(), self.table_limits.get_storage_gb()) if not_cloudsim(): self.assertIsNotNone(wait_result.get_schema()) self.assertIsNone(wait_result.get_operation_id()) # drop index by resetting the statement self.table_request.set_statement(self.drop_idx_statement) result = self.handle.table_request(self.table_request) self.assertEqual(result.get_table_name(), table_name) self.assertEqual(result.get_state(), State.UPDATING) self.assertEqual(result.get_table_limits().get_read_units(), self.table_limits.get_read_units()) self.assertEqual(result.get_table_limits().get_write_units(), self.table_limits.get_write_units()) self.assertEqual(result.get_table_limits().get_storage_gb(), self.table_limits.get_storage_gb()) if not_cloudsim(): self.assertIsNotNone(wait_result.get_schema()) wait_result = result.wait_for_state(self.handle, table_name, State.ACTIVE, wait_timeout, 1000) self.assertEqual(wait_result.get_table_name(), table_name) self.assertEqual(wait_result.get_state(), State.ACTIVE) self.assertEqual(wait_result.get_table_limits().get_read_units(), self.table_limits.get_read_units()) self.assertEqual(wait_result.get_table_limits().get_write_units(), self.table_limits.get_write_units()) self.assertEqual(wait_result.get_table_limits().get_storage_gb(), self.table_limits.get_storage_gb()) if not_cloudsim(): self.assertIsNotNone(wait_result.get_schema()) self.assertIsNone(wait_result.get_operation_id()) # drop table after dropping index self.table_request.set_statement(self.drop_tb_statement) result = self.handle.table_request(self.table_request) result.wait_for_state(self.handle, table_name, State.DROPPED, wait_timeout, 1000) def testTableRequestAlterTable(self): # create table before altering table request = TableRequest().set_statement( self.create_tb_statement).set_table_limits(self.table_limits) result = self.handle.table_request(request) result.wait_for_state(self.handle, table_name, State.ACTIVE, wait_timeout, 1000) # alter table failed with TableLimits set request.set_statement(self.alter_fld_statement) self.assertRaises(IllegalArgumentException, self.handle.table_request, request) # alter table succeed without TableLimits set self.table_request.set_statement(self.alter_fld_statement) result = self.handle.table_request(self.table_request) self.assertEqual(result.get_table_name(), table_name) self.assertEqual(result.get_state(), State.UPDATING) self.assertEqual(result.get_table_limits().get_read_units(), self.table_limits.get_read_units()) self.assertEqual(result.get_table_limits().get_write_units(), self.table_limits.get_write_units()) self.assertEqual(result.get_table_limits().get_storage_gb(), self.table_limits.get_storage_gb()) if not_cloudsim(): self.assertIsNotNone(result.get_schema()) wait_result = result.wait_for_state(self.handle, table_name, State.ACTIVE, wait_timeout, 1000) self.assertEqual(wait_result.get_table_name(), table_name) self.assertEqual(wait_result.get_state(), State.ACTIVE) self.assertEqual(wait_result.get_table_limits().get_read_units(), self.table_limits.get_read_units()) self.assertEqual(wait_result.get_table_limits().get_write_units(), self.table_limits.get_write_units()) self.assertEqual(wait_result.get_table_limits().get_storage_gb(), self.table_limits.get_storage_gb()) if not_cloudsim(): self.assertIsNotNone(wait_result.get_schema()) self.assertIsNone(wait_result.get_operation_id()) # drop table after altering table request.set_statement(self.drop_tb_statement) result = self.handle.table_request(request) result.wait_for_state(self.handle, table_name, State.DROPPED, wait_timeout, 1000) def testTableRequestAlterTableTTL(self): # create table before altering table request = TableRequest().set_statement( self.create_tb_statement).set_table_limits(self.table_limits) result = self.handle.table_request(request) result.wait_for_state(self.handle, table_name, State.ACTIVE, wait_timeout, 1000) # alter table ttl self.table_request.set_statement(self.alter_ttl_statement) result = self.handle.table_request(self.table_request) self.assertEqual(result.get_table_name(), table_name) self.assertEqual(result.get_state(), State.UPDATING) self.assertEqual(result.get_table_limits().get_read_units(), self.table_limits.get_read_units()) self.assertEqual(result.get_table_limits().get_write_units(), self.table_limits.get_write_units()) self.assertEqual(result.get_table_limits().get_storage_gb(), self.table_limits.get_storage_gb()) if not_cloudsim(): self.assertIsNotNone(result.get_schema()) wait_result = result.wait_for_state(self.handle, table_name, State.ACTIVE, wait_timeout, 1000) self.assertEqual(wait_result.get_table_name(), table_name) self.assertEqual(wait_result.get_state(), State.ACTIVE) self.assertEqual(wait_result.get_table_limits().get_read_units(), self.table_limits.get_read_units()) self.assertEqual(wait_result.get_table_limits().get_write_units(), self.table_limits.get_write_units()) self.assertEqual(wait_result.get_table_limits().get_storage_gb(), self.table_limits.get_storage_gb()) if not_cloudsim(): self.assertIsNotNone(wait_result.get_schema()) self.assertIsNone(wait_result.get_operation_id()) # drop table after altering table request.set_statement(self.drop_tb_statement) result = self.handle.table_request(request) result.wait_for_state(self.handle, table_name, State.DROPPED, wait_timeout, 1000) def testTableRequestModifyTableLimits(self): # create table before modifying the table limits request = TableRequest().set_statement( self.create_tb_statement).set_table_limits(self.table_limits) result = self.handle.table_request(request) result.wait_for_state(self.handle, table_name, State.ACTIVE, wait_timeout, 1000) # modify the table limits table_limits = TableLimits(10000, 10000, 100) self.table_request.set_table_name(table_name).set_table_limits( table_limits) result = self.handle.table_request(self.table_request) self.assertEqual(result.get_table_name(), table_name) self.assertEqual(result.get_state(), State.UPDATING) if not_cloudsim(): self.assertIsNotNone(result.get_schema()) wait_result = result.wait_for_state(self.handle, table_name, State.ACTIVE, wait_timeout, 1000) self.assertEqual(wait_result.get_table_name(), table_name) self.assertEqual(wait_result.get_state(), State.ACTIVE) self.assertEqual(wait_result.get_table_limits().get_read_units(), table_limits.get_read_units()) self.assertEqual(wait_result.get_table_limits().get_write_units(), table_limits.get_write_units()) self.assertEqual(wait_result.get_table_limits().get_storage_gb(), table_limits.get_storage_gb()) if not_cloudsim(): self.assertIsNotNone(wait_result.get_schema()) self.assertIsNone(wait_result.get_operation_id()) # drop table after modifying the table limits request.set_statement(self.drop_tb_statement) result = self.handle.table_request(request) result.wait_for_state(self.handle, table_name, State.DROPPED, wait_timeout, 1000)
class TestTableRequest(unittest.TestCase, TestBase): @classmethod def setUpClass(cls): cls.set_up_class() @classmethod def tearDownClass(cls): cls.tear_down_class() def setUp(self): self.set_up() self.handle_config = get_handle_config(tenant_id) self.create_tb_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(4), 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') self.create_idx_statement = ('CREATE INDEX ' + index_name + ' ON ' + table_name + '(fld_str, fld_double)') self.alter_fld_statement = ('ALTER TABLE ' + table_name + '(DROP fld_num)') self.alter_ttl_statement = ('ALTER TABLE ' + table_name + ' USING TTL 16 HOURS') self.drop_idx_statement = ('DROP INDEX ' + index_name + ' ON ' + table_name) self.drop_tb_statement = ('DROP TABLE IF EXISTS ' + table_name) self.table_request = TableRequest() self.table_limits = TableLimits(100, 100, 1) 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 testTableRequestSetIllegalStatement(self): self.assertRaises(IllegalArgumentException, self.table_request.set_statement, {}) self.assertRaises(IllegalArgumentException, self.table_request.set_statement, '') self.table_request.set_statement('IllegalStatement') self.assertRaises(IllegalArgumentException, self.handle.table_request, self.table_request) self.table_request.set_statement('CREATE INDEX ' + index_name + ' ON IllegalTable(fld_num)') self.assertRaises(TableNotFoundException, self.handle.table_request, self.table_request) def testTableRequestSetIllegalCompartment(self): self.assertRaises(IllegalArgumentException, self.table_request.set_compartment, {}) self.assertRaises(IllegalArgumentException, self.table_request.set_compartment, '') def testTableRequestSetIllegalTableLimits(self): self.assertRaises(IllegalArgumentException, self.table_request.set_table_limits, 'IllegalTableLimits') self.assertRaises(IllegalArgumentException, self.table_request.set_table_limits, None) self.table_request.set_statement( self.create_tb_statement).set_table_limits(TableLimits(100, 0, 1)) self.assertRaises(IllegalArgumentException, self.handle.table_request, self.table_request) def testTableRequestSetIllegalTableName(self): self.assertRaises(IllegalArgumentException, self.table_request.set_table_name, {'name': table_name}) if not is_onprem(): self.table_request.set_table_name('IllegalTable').set_table_limits( self.table_limits) self.assertRaises(TableNotFoundException, self.handle.table_request, self.table_request) def testTableRequestSetIllegalTimeout(self): self.assertRaises(IllegalArgumentException, self.table_request.set_timeout, 'IllegalTimeout') self.assertRaises(IllegalArgumentException, self.table_request.set_timeout, 0) self.assertRaises(IllegalArgumentException, self.table_request.set_timeout, -1) def testTableRequestSetIllegalDefaults(self): self.assertRaises(IllegalArgumentException, self.table_request.set_defaults, 'IllegalDefaults') def testTableRequestSetDefaults(self): self.table_request.set_defaults(self.handle_config) self.assertEqual(self.table_request.get_timeout(), table_request_timeout) def testTableRequestNoStatementAndTableName(self): self.assertRaises(IllegalArgumentException, self.handle.table_request, self.table_request) def testTableRequestBothStatementAndTableName(self): self.table_request.set_statement( self.create_tb_statement).set_table_name(table_name) self.assertRaises(IllegalArgumentException, self.handle.table_request, self.table_request) def testTableRequestOnlyTableName(self): self.table_request.set_table_name(table_name) self.assertRaises(IllegalArgumentException, self.handle.table_request, self.table_request) def testTableRequestGets(self): self.table_request.set_table_name(table_name).set_statement( self.create_tb_statement).set_table_limits(self.table_limits) self.assertEqual(self.table_request.get_statement(), self.create_tb_statement) self.assertIsNone(self.table_request.get_compartment()) self.assertEqual(self.table_request.get_table_limits(), self.table_limits) self.assertEqual(self.table_request.get_table_name(), table_name) def testTableRequestIllegalRequest(self): self.assertRaises(IllegalArgumentException, self.handle.table_request, 'IllegalRequest') def testTableRequestCreateDropTable(self): # create table failed without TableLimits set self.table_request.set_statement(self.create_tb_statement) if not is_onprem(): self.assertRaises(IllegalArgumentException, self.handle.table_request, self.table_request) # create table succeed with TableLimits set self.table_request.set_table_limits(self.table_limits) result = self.handle.table_request(self.table_request) if is_onprem(): self.check_table_result(result, State.CREATING, has_schema=False) else: self.check_table_result(result, State.CREATING, self.table_limits, False) result.wait_for_completion(self.handle, wait_timeout, 1000) self.check_table_result(result, State.ACTIVE, self.table_limits) # drop table by resetting the statement self.table_request.set_statement(self.drop_tb_statement) result = self.handle.table_request(self.table_request) self.check_table_result(result, State.DROPPING, check_limit=False, check_schema=False) result.wait_for_completion(self.handle, wait_timeout, 1000) self.check_table_result(result, State.DROPPED, has_schema=False) def testTableRequestCreateDropIndex(self): # create table before creating index request = TableRequest().set_statement( self.create_tb_statement).set_table_limits(self.table_limits) self._do_table_request(request) # create index by resetting the statement self.table_request.set_statement(self.create_idx_statement) result = self.handle.table_request(self.table_request) self.check_table_result(result, State.UPDATING, check_limit=False, check_schema=False) result.wait_for_completion(self.handle, wait_timeout, 1000) self.check_table_result(result, State.ACTIVE, self.table_limits) # drop index by resetting the statement self.table_request.set_statement(self.drop_idx_statement) result = self.handle.table_request(self.table_request) self.check_table_result(result, State.UPDATING, check_limit=False, check_schema=False) result.wait_for_completion(self.handle, wait_timeout, 1000) self.check_table_result(result, State.ACTIVE, self.table_limits) # drop table after dropping index self.table_request.set_statement(self.drop_tb_statement) self._do_table_request(self.table_request) def testTableRequestAlterTable(self): # create table before altering table request = TableRequest().set_statement( self.create_tb_statement).set_table_limits(self.table_limits) self._do_table_request(request) # alter table failed with TableLimits set if not is_onprem(): request.set_statement(self.alter_fld_statement) self.assertRaises(IllegalArgumentException, self.handle.table_request, request) # alter table succeed without TableLimits set self.table_request.set_statement(self.alter_fld_statement) result = self.handle.table_request(self.table_request) self.check_table_result(result, State.UPDATING, check_limit=False, check_schema=False) result.wait_for_completion(self.handle, wait_timeout, 1000) self.check_table_result(result, State.ACTIVE, self.table_limits) # drop table after altering table request.set_statement(self.drop_tb_statement) self._do_table_request(request) def testTableRequestAlterTableTTL(self): # create table before altering table request = TableRequest().set_statement( self.create_tb_statement).set_table_limits(self.table_limits) self._do_table_request(request) # alter table ttl self.table_request.set_statement(self.alter_ttl_statement) result = self.handle.table_request(self.table_request) self.check_table_result(result, State.UPDATING, check_limit=False, check_schema=False) result.wait_for_completion(self.handle, wait_timeout, 1000) self.check_table_result(result, State.ACTIVE, self.table_limits) # drop table after altering table request.set_statement(self.drop_tb_statement) self._do_table_request(request) def testTableRequestModifyTableLimits(self): # create table before modifying the table limits request = TableRequest().set_statement( self.create_tb_statement).set_table_limits(self.table_limits) self._do_table_request(request) # modify the table limits table_limits = TableLimits(50, 50, 1) self.table_request.set_table_name(table_name).set_table_limits( table_limits) if is_onprem(): self.assertRaises(OperationNotSupportedException, self.handle.table_request, self.table_request) return result = self.handle.table_request(self.table_request) self.check_table_result(result, State.UPDATING, check_limit=False, check_schema=False) result.wait_for_completion(self.handle, wait_timeout, 1000) self.check_table_result(result, State.ACTIVE, table_limits) # drop table after modifying the table limits request.set_statement(self.drop_tb_statement) self._do_table_request(request) def _do_table_request(self, request): # # Optionally delay to handle the 4 DDL ops/minute limit # in the real service # if is_pod(): sleep(30) result = self.handle.table_request(request) result.wait_for_completion(self.handle, wait_timeout, 1000)
class TestTableRequest(unittest.TestCase, TestBase): @classmethod def setUpClass(cls): cls.set_up_class() @classmethod def tearDownClass(cls): cls.tear_down_class() def setUp(self): self.set_up() self.handle_config = get_handle_config(tenant_id) index_name = 'idx_' + table_name self.create_tb_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(4), 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') self.create_idx_statement = ( 'CREATE INDEX ' + index_name + ' ON ' + table_name + '(fld_str, fld_double)') self.alter_fld_statement = ( 'ALTER TABLE ' + table_name + '(DROP fld_num)') self.alter_ttl_statement = ( 'ALTER TABLE ' + table_name + ' USING TTL 16 HOURS') self.drop_idx_statement = ( 'DROP INDEX ' + index_name + ' ON ' + table_name) self.drop_tb_statement = ('DROP TABLE IF EXISTS ' + table_name) self.table_request = TableRequest() self.table_limits = TableLimits(5000, 5000, 50) def tearDown(self): try: TableResult.wait_for_state(self.handle, State.ACTIVE, wait_timeout, 1000, table_name) drop_request = TableRequest().set_statement(self.drop_tb_statement) self._do_table_request(drop_request) except TableNotFoundException: pass finally: self.tear_down() def testTableRequestSetIllegalStatement(self): self.assertRaises(IllegalArgumentException, self.table_request.set_statement, {}) self.assertRaises(IllegalArgumentException, self.table_request.set_statement, '') self.table_request.set_statement('IllegalStatement') self.assertRaises(IllegalArgumentException, self.handle.table_request, self.table_request) self.table_request.set_statement( 'ALTER TABLE IllegalTable (DROP fld_num)') self.assertRaises(TableNotFoundException, self.handle.table_request, self.table_request) def testTableRequestSetIllegalTableLimits(self): self.assertRaises(IllegalArgumentException, self.table_request.set_table_limits, 'IllegalTableLimits') self.assertRaises(IllegalArgumentException, self.table_request.set_table_limits, None) self.table_request.set_statement( self.create_tb_statement).set_table_limits(TableLimits(5000, 0, 50)) self.assertRaises(IllegalArgumentException, self.handle.table_request, self.table_request) def testTableRequestSetIllegalTableName(self): self.assertRaises(IllegalArgumentException, self.table_request.set_table_name, {'name': table_name}) if not is_onprem(): self.table_request.set_table_name('IllegalTable').set_table_limits( self.table_limits) self.assertRaises(TableNotFoundException, self.handle.table_request, self.table_request) def testTableRequestSetIllegalTimeout(self): self.assertRaises(IllegalArgumentException, self.table_request.set_timeout, 'IllegalTimeout') self.assertRaises(IllegalArgumentException, self.table_request.set_timeout, 0) self.assertRaises(IllegalArgumentException, self.table_request.set_timeout, -1) def testTableRequestSetIllegalDefaults(self): self.assertRaises(IllegalArgumentException, self.table_request.set_defaults, 'IllegalDefaults') def testTableRequestSetDefaults(self): self.table_request.set_defaults(self.handle_config) self.assertEqual(self.table_request.get_timeout(), table_request_timeout) def testTableRequestNoStatementAndTableName(self): self.assertRaises(IllegalArgumentException, self.handle.table_request, self.table_request) def testTableRequestBothStatementAndTableName(self): self.table_request.set_statement( self.create_tb_statement).set_table_name(table_name) self.assertRaises(IllegalArgumentException, self.handle.table_request, self.table_request) def testTableRequestOnlyTableName(self): self.table_request.set_table_name(table_name) self.assertRaises(IllegalArgumentException, self.handle.table_request, self.table_request) def testTableRequestGets(self): self.table_request.set_table_name(table_name).set_statement( self.create_tb_statement).set_table_limits(self.table_limits) self.assertEqual(self.table_request.get_statement(), self.create_tb_statement) self.assertEqual(self.table_request.get_table_limits(), self.table_limits) self.assertEqual(self.table_request.get_table_name(), table_name) def testTableRequestIllegalRequest(self): self.assertRaises(IllegalArgumentException, self.handle.table_request, 'IllegalRequest') def testTableRequestCreateDropTable(self): # create table failed without TableLimits set self.table_request.set_statement(self.create_tb_statement) if not is_onprem(): self.assertRaises(IllegalArgumentException, self.handle.table_request, self.table_request) # create table succeed with TableLimits set self.table_request.set_table_limits(self.table_limits) result = self.handle.table_request(self.table_request) self.check_table_result( result, State.CREATING, self.table_limits, False) self._wait_for_completion(result) self.check_table_result(result, State.ACTIVE, self.table_limits) # drop table by resetting the statement self.table_request.set_statement(self.drop_tb_statement) result = self.handle.table_request(self.table_request) # TODO: A difference between old cloud proxy and new cloud proxy, during # DROPPING phase, the table limit is not none for old proxy but none for # new proxy. self._check_table_result(result, State.DROPPING, check_limit=False) self._wait_for_completion(result) # TODO: A difference between old cloud proxy and new cloud proxy, after # table DROPPED, the table limit is not none for old proxy but none for # new proxy. self._check_table_result(result, State.DROPPED, has_schema=False, check_limit=False) def testTableRequestCreateDropIndex(self): # create table before creating index request = TableRequest().set_statement( self.create_tb_statement).set_table_limits(self.table_limits) self._do_table_request(request) # create index by resetting the statement self.table_request.set_statement(self.create_idx_statement) result = self.handle.table_request(self.table_request) self._check_table_result(result, State.UPDATING, self.table_limits) self._wait_for_completion(result) self._check_table_result(result, State.ACTIVE, self.table_limits) # drop index by resetting the statement self.table_request.set_statement(self.drop_idx_statement) result = self.handle.table_request(self.table_request) self._check_table_result(result, State.UPDATING, self.table_limits) self._wait_for_completion(result) self._check_table_result(result, State.ACTIVE, self.table_limits) # drop table after dropping index self.table_request.set_statement(self.drop_tb_statement) self._do_table_request(self.table_request) def testTableRequestAlterTable(self): # create table before altering table request = TableRequest().set_statement( self.create_tb_statement).set_table_limits(self.table_limits) self._do_table_request(request) # alter table failed with TableLimits set if not is_onprem(): request.set_statement(self.alter_fld_statement) self.assertRaises(IllegalArgumentException, self.handle.table_request, request) # alter table succeed without TableLimits set self.table_request.set_statement(self.alter_fld_statement) result = self.handle.table_request(self.table_request) self.check_table_result(result, State.UPDATING, self.table_limits) self._wait_for_completion(result) self.check_table_result(result, State.ACTIVE, self.table_limits) # drop table after altering table request.set_statement(self.drop_tb_statement) self._do_table_request(request) def testTableRequestAlterTableTTL(self): # create table before altering table request = TableRequest().set_statement( self.create_tb_statement).set_table_limits(self.table_limits) self._do_table_request(request) # alter table ttl self.table_request.set_statement(self.alter_ttl_statement) result = self.handle.table_request(self.table_request) self.check_table_result(result, State.UPDATING, self.table_limits) self._wait_for_completion(result) self.check_table_result(result, State.ACTIVE, self.table_limits) # drop table after altering table request.set_statement(self.drop_tb_statement) self._do_table_request(request) def testTableRequestModifyTableLimits(self): # create table before modifying the table limits request = TableRequest().set_statement( self.create_tb_statement).set_table_limits(self.table_limits) self._do_table_request(request) # modify the table limits table_limits = TableLimits(10000, 10000, 100) self.table_request.set_table_name(table_name).set_table_limits( table_limits) if is_onprem(): self.assertRaises(OperationNotSupportedException, self.handle.table_request, self.table_request) return result = self.handle.table_request(self.table_request) self.assertEqual(result.get_table_name(), table_name) self.assertEqual(result.get_state(), State.UPDATING) if not_cloudsim(): self.assertIsNotNone(result.get_schema()) self.assertIsNotNone(result.get_operation_id()) self._wait_for_completion(result) self.check_table_result(result, State.ACTIVE, table_limits) # drop table after modifying the table limits request.set_statement(self.drop_tb_statement) self._do_table_request(request) def _check_table_result(self, result, state, table_limits=None, has_schema=True, check_limit=True): # TODO: For minicloud, the SC module doesn't return operation id for # now. This affects drop table as well as create/drop index. When the SC # is changed to return the operation id, the test need to be changed. if is_minicloud(): self.check_table_result(result, state, table_limits, has_schema, False, check_limit) else: self.check_table_result(result, state, table_limits, has_schema, check_limit=check_limit) def _do_table_request(self, request): # # Optionally delay to handle the 4 DDL ops/minute limit # in the real service # if is_pod(): sleep(20) result = self.handle.table_request(request) self._wait_for_completion(result) def _wait_for_completion(self, result): # TODO: For minicloud, the SC module doesn't return operation id for # now. In TableResult.wait_for_completion, it check if the operation id # is none, if none, raise IllegalArgumentException, at the moment we # should ignore this exception in minicloud testing. This affects drop # table as well as create/drop index. When the SC is changed to return # the operation id, the test need to be changed. if is_minicloud(): result.wait_for_state(self.handle, [State.ACTIVE, State.DROPPED], wait_timeout, 1000, result=result) else: result.wait_for_completion(self.handle, wait_timeout, 1000)