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 setUpClass(cls): cls.set_up_class() create_statement = ('CREATE TABLE ' + table_name + '(id integer, \ name string, primary key(id))') create_request = TableRequest().set_statement( create_statement).set_table_limits(TableLimits(100, 100, 1)) cls.table_request(create_request)
def testPutWithIdentityColumn(self): id_table = table_prefix + 'Identity' create_request = TableRequest().set_statement( 'CREATE TABLE ' + id_table + '(sid INTEGER, id LONG GENERATED \ ALWAYS AS IDENTITY, name STRING, PRIMARY KEY(SHARD(sid), id))') create_request.set_table_limits(TableLimits(50, 50, 1)) self.table_request(create_request) # test put a row with an extra field not in the table, by default this # will succeed row = {'name': 'myname', 'extra': 'extra', 'sid': 1} key = {'sid': 1, 'id': 1} expected = OrderedDict() expected['sid'] = 1 expected['id'] = 1 expected['name'] = 'myname' self.put_request.set_table_name(id_table).set_value(row) result = self.handle.put(self.put_request) version = result.get_version() self._check_put_result(result, has_generated_value=True) self.check_cost(result, 0, 0, 1, 1) self.get_request.set_table_name(id_table).set_key(key) result = self.handle.get(self.get_request) self.check_get_result(result, expected, version) self.check_cost(result, 1, 2, 0, 0) # test put a row with identity field, this will fail because id is # 'generated always' and in that path it is not legal to provide a value # for id row['id'] = 1 self.assertRaises(IllegalArgumentException, self.handle.put, self.put_request)
def setUpClass(cls): cls.handle = None 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(7), 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(5000, 5000, 50) create_request = TableRequest().set_statement( create_statement).set_table_limits(limits) cls.table_request(create_request) # put and get some data, read_units = 100, write_units = 199 row = get_row() key = {'fld_id': 1} put_request = PutRequest().set_value(row).set_table_name(table_name) get_request = GetRequest().set_key(key).set_table_name(table_name) count = 0 while count < 100: cls.handle.put(put_request) cls.handle.get(get_request) count += 1 # sleep to allow records to accumulate over time, but not if # using Cloudsim. if not_cloudsim() and not is_onprem(): sleep(2) # need to sleep to allow usage records to accumulate but not if # using CloudSim, which doesn't generate usage records. if not_cloudsim() and not is_onprem(): sleep(40)
def testWriteMultipleWithIdentityColumn(self): num_operations = 10 id_table = table_prefix + 'Identity' create_request = TableRequest().set_statement( 'CREATE TABLE ' + id_table + '(sid INTEGER, id LONG GENERATED \ ALWAYS AS IDENTITY, name STRING, PRIMARY KEY(SHARD(sid), id))') create_request.set_table_limits(TableLimits(5000, 5000, 50)) self.table_request(create_request) # add ten operations row = {'name': 'myname', 'sid': 1} for idx in range(num_operations): put_request = PutRequest().set_table_name(id_table).set_value(row) put_request.set_identity_cache_size(idx) self.write_multiple_request.add(put_request, False) # execute the write multiple request versions = list() result = self.handle.write_multiple(self.write_multiple_request) op_results = self._check_write_multiple_result(result, num_operations) for idx in range(result.size()): versions.append( self._check_operation_result(op_results[idx], True, True, idx + 1)) self.check_cost(result, 0, 0, num_operations, num_operations) # check the records after write_multiple request succeed self.get_request.set_table_name(id_table) for idx in range(num_operations): self.get_request.set_key({'sid': 1, 'id': idx + 1}) result = self.handle.get(self.get_request) expected = OrderedDict() expected['sid'] = 1 expected['id'] = idx + 1 expected['name'] = 'myname' self.check_get_result(result, expected, versions[idx]) self.check_cost(result, 1, 2, 0, 0)
def setUpClass(cls): TestBase.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._result = TestBase.table_request(create_request, State.ACTIVE) create_index_statement = ('CREATE INDEX ' + index_name + ' ON ' + table_name + '(fld_long)') create_index_request = TableRequest().set_statement( create_index_statement) cls._result = TestBase.table_request(create_index_request, State.ACTIVE) global prepare_cost prepare_cost = 2 global query_statement query_statement = ('SELECT fld_sid, fld_id FROM ' + table_name + ' WHERE fld_sid = 1')
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(7), 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(5000, 5000, 50) create_request = TableRequest().set_statement( create_statement).set_table_limits(limits) cls._result = TestBase.table_request(create_request, State.ACTIVE) # put and get some data, read_units = 100, write_units = 199 row = { 'fld_id': 1, 'fld_long': 2147483648, 'fld_float': 3.1414999961853027, 'fld_double': 3.1415, 'fld_bool': True, 'fld_str': '{"name": u1, "phone": null}', 'fld_bin': bytearray(pack('>i', 4)), 'fld_time': datetime.now(), 'fld_num': Decimal(5), 'fld_json': { 'a': '1', 'b': None, 'c': '3' }, 'fld_arr': ['a', 'b', 'c'], 'fld_map': { 'a': '1', 'b': '2', 'c': '3' }, 'fld_rec': { 'fld_id': 1, 'fld_bool': False, 'fld_str': None } } key = {'fld_id': 1} put_request = PutRequest().set_value(row).set_table_name(table_name) get_request = GetRequest().set_key(key).set_table_name(table_name) count = 0 while count < 100: cls._handle.put(put_request) cls._handle.get(get_request) count += 1 # sleep to allow records to accumulate over time, but not if # using Cloudsim. if not_cloudsim(): sleep(2) # need to sleep to allow usage records to accumulate but not if # using CloudSim, which doesn't generate usage records. if not_cloudsim(): sleep(40)
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 testTableLimitsNegativeValues(self): # negative read units self.table_request.set_table_limits(TableLimits(-1, 10, 1)) self.assertRaises(IllegalArgumentException, self.handle.table_request, self.table_request) # read_units = 0 self.table_request.set_table_limits(TableLimits(0, 10, 1)) self.assertRaises(IllegalArgumentException, self.handle.table_request, self.table_request) # negative write units self.table_request.set_table_limits(TableLimits(30, -1, 1)) self.assertRaises(IllegalArgumentException, self.handle.table_request, self.table_request) # write_units = 0 self.table_request.set_table_limits(TableLimits(30, 0, 1)) self.assertRaises(IllegalArgumentException, self.handle.table_request, self.table_request) # negative storage gb self.table_request.set_table_limits(TableLimits(30, 10, -1)) self.assertRaises(IllegalArgumentException, self.handle.table_request, self.table_request) # storage_gb = 0 self.table_request.set_table_limits(TableLimits(30, 10, 0)) self.assertRaises(IllegalArgumentException, self.handle.table_request, self.table_request)
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(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(5000, 5000, 50) create_request = TableRequest().set_statement( create_statement).set_table_limits(limits) cls._result = TestBase.table_request(create_request, State.ACTIVE)
def setUpClass(cls): cls.set_up_class() 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(8), 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(50, 50, 1) create_request = TableRequest().set_statement( create_statement).set_table_limits(limits) cls.table_request(create_request)
def setUpClass(cls): cls.set_up_class() global table_ttl table_ttl = TimeToLive.of_days(2) 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(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(fld_id)) USING TTL ' + str(table_ttl)) create_request = TableRequest().set_statement( create_statement).set_table_limits(TableLimits(100, 100, 1)) cls.table_request(create_request)
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 setUpClass(cls): add_tier() cls._handles = list() cls._drop_requests = list() global table_names table_names = list() num_tables = 3 # # In pod env create 1 handle, otherwise create 2 handles for additional # testing # cls._num_handles = 1 if is_pod() else 2 for handle in range(cls._num_handles): add_tenant(tenant_id + str(handle)) table_names.append(list()) cls._drop_requests.append(list()) cls._handles.append(get_handle(tenant_id + str(handle))) for table in range(handle + num_tables): table_names[handle].append(table_name + str(table)) for table in range(handle + num_tables): # # Add a sleep for a pod to let things happen # if is_pod(): sleep(60) drop_statement = ('DROP TABLE IF EXISTS ' + table_names[handle][table]) drop_request = TableRequest().set_statement(drop_statement) cls._drop_requests[handle].append(drop_request) cls._result = cls._handles[handle].table_request(drop_request) cls._result.wait_for_state(cls._handles[handle], table_names[handle][table], State.DROPPED, wait_timeout, 1000) create_statement = ('CREATE TABLE ' + table_names[handle][table] + '(\ fld_id INTEGER, fld_long LONG, fld_float FLOAT, fld_double DOUBLE, \ fld_bool BOOLEAN, fld_str STRING, fld_bin BINARY, fld_time TIMESTAMP(2), \ 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 16 HOURS') limits = TableLimits(5000, 5000, 50) create_request = TableRequest().set_statement( create_statement).set_table_limits(limits) cls._result = cls._handles[handle].table_request( create_request) cls._result.wait_for_state(cls._handles[handle], table_names[handle][table], State.ACTIVE, wait_timeout, 1000)
def setUpClass(cls): TestBase.set_up_class() table_ttl = TimeToLive.of_hours(16) 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(7), 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)) USING TTL ' + str(table_ttl)) create_request = TableRequest().set_statement( create_statement).set_table_limits(TableLimits(5000, 5000, 50)) cls._result = TestBase.table_request(create_request, State.ACTIVE) global row, tb_expect_expiration, hour_in_milliseconds row = { 'fld_sid': 1, 'fld_id': 1, 'fld_long': 2147483648, 'fld_float': 3.1414999961853027, 'fld_double': 3.1415, 'fld_bool': True, 'fld_str': '{"name": u1, "phone": null}', 'fld_bin': bytearray(pack('>i', 4)), 'fld_time': datetime.now(), 'fld_num': Decimal(5), 'fld_json': { 'a': '1', 'b': None, 'c': '3' }, 'fld_arr': ['a', 'b', 'c'], 'fld_map': { 'a': '1', 'b': '2', 'c': '3' }, 'fld_rec': { 'fld_id': 1, 'fld_bool': False, 'fld_str': None } } put_request = PutRequest().set_value(row).set_table_name(table_name) cls._handle.put(put_request) tb_expect_expiration = table_ttl.to_expiration_time( int(round(time() * 1000))) hour_in_milliseconds = 60 * 60 * 1000
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.handle = None cls.set_up_class() table_ttl = TimeToLive.of_hours(16) 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(7), 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)) USING TTL ' + str(table_ttl)) create_request = TableRequest().set_statement( create_statement).set_table_limits(TableLimits(100, 100, 1)) cls.table_request(create_request) global row, tb_expect_expiration, version row = get_row() put_request = PutRequest().set_value(row).set_table_name(table_name) version = cls.handle.put(put_request).get_version() tb_expect_expiration = table_ttl.to_expiration_time( int(round(time() * 1000)))
def setUpClass(cls): add_tier() cls.handles = list() global table_names table_names = list() num_tables = 3 # # In pod env create 1 handle, otherwise create 2 handles for additional # testing # num_handles = 1 if is_prod_pod() or is_onprem() else 2 for handle in range(num_handles): tenant = tenant_id + ('' if handle == 0 else str(handle)) add_tenant(tenant) table_names.append(list()) cls.handles.append(get_handle(tenant)) for table in range(handle + num_tables): tb_name = table_name + str(table) table_names[handle].append(tb_name) # # Add a sleep for a pod to let things happen # if is_pod(): sleep(60) drop_request = TableRequest().set_statement( 'DROP TABLE IF EXISTS ' + tb_name) cls.table_request(drop_request, cls.handles[handle]) create_statement = ('CREATE TABLE ' + tb_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(2), 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 16 HOURS') limits = TableLimits(10, 10, 1) create_request = TableRequest().set_statement( create_statement).set_table_limits(limits) cls.table_request(create_request, cls.handles[handle])
def setUpClass(cls): cls.set_up_class() global table_names, index_names, num_indexes, index_fields table_names = list() num_tables = 2 index_names = list() num_indexes = 1 index_fields = list() for index in range(2): index_fields.append(list()) index_fields[0].append('fld_double') index_fields[1].append('fld_str') for table in range(num_tables): tb_name = table_name + str(table) table_names.append(tb_name) create_statement = ('CREATE TABLE ' + tb_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(0), 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 2 DAYS') limits = TableLimits(50, 50, 1) create_request = TableRequest().set_statement( create_statement).set_table_limits(limits) cls.table_request(create_request) index_names.append(list()) for index in range(table + num_indexes): idx_name = index_name + str(index) index_names[table].append(idx_name) create_index_statement = ('CREATE INDEX ' + idx_name + ' ON ' + tb_name + '(' + ','.join(index_fields[index]) + ')') create_index_request = TableRequest().set_statement( create_index_statement) cls.table_request(create_index_request) if is_minicloud(): index_names[table].reverse()
def _run_limited_ops_on_table(self, read_limit, write_limit, max_seconds, max_rows, use_percent, use_external_limiters): """ Runs get/puts then queries on a table. Verify RUs/WUs are within given limits. """ self._alter_table_limits(TableLimits(read_limit, write_limit, 50)) """ We have to do the read/write ops separately since we're running single-threaded, and the result is hard to tell if it's correct (example: we'd get 37RUs and 15WUs). """ self._do_rate_limited_ops(max_seconds, 0, write_limit, max_rows, True, use_percent, use_external_limiters) self._do_rate_limited_ops(max_seconds, read_limit, 0, max_rows, True, use_percent, use_external_limiters) # Query based on single partition scanning. self._do_rate_limited_queries(max_seconds, read_limit, 20, True, use_percent, use_external_limiters) # Query based on all partitions scanning. self._do_rate_limited_queries(max_seconds, read_limit, 20, False, use_percent, use_external_limiters)
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 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(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 setUp(self): self.handle = get_handle(tenant_id) self.limits = TableLimits(30, 10, 1) self.table_request = TableRequest().set_statement( 'CREATE TABLE ' + table_name + '(fld_id INTEGER, fld_long LONG, \ PRIMARY KEY(fld_id))')
def main(): handle = None try: # # Create a handle # handle = get_handle(tenant_id) # # 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, 50000, 3000) print('After create table') # # Put a few rows # request = PutRequest().set_table_name(table_name) for i in range(10): value = {'id': i, 'sid': 0, 'name': 'myname' + str(i)} request.set_value(value) handle.put(request) print('After put of 10 rows') # # Get the row # request = GetRequest().set_key({ 'id': 1, 'sid': 0 }).set_table_name(table_name) result = handle.get(request) print('After get: ' + str(result)) # # Query, using a range # statement = 'select * from ' + table_name + ' where id > 2 and id < 8' request = QueryRequest().set_statement(statement) result = handle.query(request) print('Query results for: ' + statement) for r in result.get_results(): print('\t' + str(r)) # # Delete the row # request = DeleteRequest().set_key({ 'id': 1, 'sid': 0 }).set_table_name(table_name) result = handle.delete(request) print('After delete: ' + str(result)) # # Get again to show deletion # request = GetRequest().set_key({ 'id': 1, 'sid': 0 }).set_table_name(table_name) result = handle.get(request) print('After get (should be None): ' + str(result)) # # 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, 40000, 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 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)
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 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()
def main(): handle = None try: # # Create a handle # handle = get_handle(tenant_id) # # 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, 50000, 3000) print('After create table') # # Put a few rows # request = PutRequest().set_table_name(table_name) for i in range(10): value = {'id': i, 'sid': 0, 'name': 'myname' + str(i)} request.set_value(value) handle.put(request) print('After put of 10 rows') # # Multiple write a few rows # request = WriteMultipleRequest() for i in range(10): value = {'id': i, 'sid': 0, 'name': 'newname' + str(i)} request.add( PutRequest().set_value(value).set_table_name(table_name), True) result = handle.write_multiple(request) print('After multiple write: ' + str(result)) # # Prepare a statement # statement = 'select * from ' + table_name + ' where id > 2 and id < 8' request = PrepareRequest().set_statement(statement) prepared_result = handle.prepare(request) print('After prepare the statement: ' + statement) # # Query, using the prepared statement # request = QueryRequest().set_prepared_statement(prepared_result) print('Query results for the prepared statement: ') while True: result = handle.query(request) for r in result.get_results(): print('\t' + str(r)) if request.is_done(): break # # Multiple delete the rows # request = MultiDeleteRequest().set_table_name(table_name).set_key( {'sid': 0}) result = handle.multi_delete(request) print('After multiple delete: ' + str(result)) # # Query again to show deletions, using the prepared statement # request = QueryRequest().set_prepared_statement(prepared_result) print('Query results for the prepared statement (should be no rows): ') while True: result = handle.query(request) for r in result.get_results(): print('\t' + str(r)) if request.is_done(): break # # Drop the table # if drop_table: request = TableRequest().set_statement('drop table if exists ' + table_name) handle.do_table_request(request, 40000, 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()
# create the handle. nosql_handle = NoSQLHandle(handle_config) table_ddl = """ CREATE TABLE produtos ( id INTEGER GENERATED BY DEFAULT ON NULL AS IDENTITY (START WITH 1 INCREMENT BY 1), propriedades JSON, valor NUMBER, frete_gratis BOOLEAN, imagens ARRAY(STRING), PRIMARY KEY(id)) """ # 10 Read Units (RU) # 5 Write Units (WU) # 1 GB of Storage table_limits = TableLimits(10, 5, 1) # creates a request object that contains the DLL instruction and # throughput/capacity limits. table_request = TableRequest() table_request.set_statement(table_ddl) table_request.set_table_limits(table_limits) # perform the creation of the new nosql table. nosql_handle.table_request(table_request) # free up the resources from handle. nosql_handle.close()