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()
