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 testWriteMultipleAddIllegalRequestAndAbortIfUnsuccessful(self):
self.assertRaises(IllegalArgumentException,
self.write_multiple_request.add, 'IllegalRequest',
True)
self.assertRaises(IllegalArgumentException,
self.write_multiple_request.add, PutRequest(),
'IllegalAbortIfUnsuccessful')
# add two operations with different table name
self.write_multiple_request.add(self.requests[0], True)
self.assertRaises(IllegalArgumentException,
self.write_multiple_request.add,
self.illegal_requests[0], False)
self.write_multiple_request.clear()
# add two operations with different major paths
self.write_multiple_request.add(self.requests[0],
True).add(self.illegal_requests[1],
False)
self.assertRaises(IllegalArgumentException, self.handle.write_multiple,
self.write_multiple_request)
self.write_multiple_request.clear()
# add operations when sub requests reached the max number
if not is_onprem():
count = 0
while count <= 50:
row = get_row()
row['fld_id'] = count
self.write_multiple_request.add(
PutRequest().set_value(row).set_table_name(table_name),
True)
count += 1
self.assertRaises(BatchOperationNumberLimitException,
self.handle.write_multiple,
self.write_multiple_request)
def testWriteMultipleAddIllegalRequestAndAbortIfUnsuccessful(self):
self.assertRaises(IllegalArgumentException,
self.write_multiple_request.add, 'IllegalRequest',
True)
self.assertRaises(IllegalArgumentException,
self.write_multiple_request.add, PutRequest(),
'IllegalAbortIfUnsuccessful')
# add two operations with different table name
self.write_multiple_request.add(self.requests[0], True)
self.assertRaises(IllegalArgumentException,
self.write_multiple_request.add,
self.illegal_requests[0], False)
self.write_multiple_request.clear()
# add two operations with different major paths
self.write_multiple_request.add(self.requests[0],
True).add(self.illegal_requests[1],
False)
self.assertRaises(IllegalArgumentException, self.handle.write_multiple,
self.write_multiple_request)
if not is_onprem():
# add operations when the request size exceeded the limit
self.write_multiple_request.clear()
for op in range(64):
row = get_row()
row['fld_str'] = self.get_random_str(0.4)
self.write_multiple_request.add(
PutRequest().set_value(row).set_table_name(table_name),
True)
self.assertRaises(RequestSizeLimitException,
self.handle.write_multiple,
self.write_multiple_request)
# add operations when sub requests reached the max number
self.write_multiple_request.clear()
for op in range(51):
row = get_row()
row['fld_id'] = op
self.write_multiple_request.add(
PutRequest().set_value(row).set_table_name(table_name),
True)
self.assertRaises(BatchOperationNumberLimitException,
self.handle.write_multiple,
self.write_multiple_request)
def setUp(self):
self.set_up()
self.row = get_row(with_sid=False)
self.key = {'fld_id': 1}
self.put_request = PutRequest().set_value(
self.row).set_table_name(table_name)
self.version = self.handle.put(self.put_request).get_version()
self.get_request = GetRequest().set_key(
self.key).set_table_name(table_name)
self.delete_request = DeleteRequest().set_key(
self.key).set_table_name(table_name).set_timeout(timeout)
def setUp(self):
self.set_up()
self.row = get_row(with_sid=False)
self.key = {'fld_id': 1}
self.put_request = PutRequest().set_value(
self.row).set_table_name(table_name).set_timeout(timeout)
self.get_request = GetRequest().set_key(
self.key).set_table_name(table_name)
self.ttl = TimeToLive.of_hours(24)
self.hour_in_milliseconds = 60 * 60 * 1000
self.day_in_milliseconds = 24 * 60 * 60 * 1000
def setUp(self):
self.set_up()
self.handle_config = get_handle_config(tenant_id)
self.min_time = list()
self.max_time = list()
shardkeys = 2
ids = 6
write_multiple_request = WriteMultipleRequest()
for sk in range(shardkeys):
for i in range(ids):
row = get_row()
if i == 0:
self.min_time.append(row['fld_time'])
elif i == ids - 1:
self.max_time.append(row['fld_time'])
row['fld_sid'] = sk
row['fld_id'] = i
row['fld_bool'] = False if sk == 0 else True
row['fld_str'] = (
'{"name": u' +
str(shardkeys * ids - sk * ids - i - 1).zfill(2) + '}')
row['fld_json']['location']['coordinates'] = ([
23.549 - sk * 0.5 - i, 35.2908 + sk * 0.5 + i
])
write_multiple_request.add(
PutRequest().set_value(row).set_table_name(table_name),
True)
self.handle.write_multiple(write_multiple_request)
write_multiple_request.clear()
prepare_statement_update = (
'DECLARE $fld_sid INTEGER; $fld_id INTEGER; UPDATE ' + table_name +
' u SET u.fld_long = u.fld_long + 1 WHERE fld_sid = $fld_sid ' +
'AND fld_id = $fld_id')
prepare_request_update = PrepareRequest().set_statement(
prepare_statement_update)
self.prepare_result_update = self.handle.prepare(
prepare_request_update)
prepare_statement_select = (
'DECLARE $fld_long LONG; SELECT fld_sid, fld_id, fld_long FROM ' +
table_name + ' WHERE fld_long = $fld_long')
prepare_request_select = PrepareRequest().set_statement(
prepare_statement_select)
self.prepare_result_select = self.handle.prepare(
prepare_request_select)
self.query_request = QueryRequest().set_timeout(timeout)
self.get_request = GetRequest().set_table_name(table_name)
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 setUp(self):
self.set_up()
self.shardkeys = [0, 1]
ids = [0, 1, 2, 3, 4, 5]
write_multiple_request = WriteMultipleRequest()
for sk in self.shardkeys:
for i in ids:
row = get_row()
row['fld_sid'] = sk
row['fld_id'] = i
write_multiple_request.add(
PutRequest().set_value(row).set_table_name(table_name),
True)
self.handle.write_multiple(write_multiple_request)
write_multiple_request.clear()
self.key = {'fld_sid': 1}
self.multi_delete_request = MultiDeleteRequest().set_timeout(timeout)
prep_request = PrepareRequest().set_statement(
'SELECT fld_sid, fld_id FROM ' + table_name)
prep_result = self.handle.prepare(prep_request)
self.query_request = QueryRequest().set_prepared_statement(prep_result)
def setUp(self):
self.set_up()
self.shardkeys = [0, 1]
self.ids = [0, 1, 2, 3, 4, 5]
self.rows = list()
self.new_rows = list()
self.versions = list()
self.requests = list()
self.illegal_requests = list()
ttl = TimeToLive.of_days(16)
for sk in self.shardkeys:
self.rows.append(list())
self.new_rows.append(list())
self.versions.append(list())
for i in self.ids:
row = get_row()
row['fld_sid'] = sk
row['fld_id'] = i
new_row = deepcopy(row)
new_row['fld_long'] = 2147483649
self.rows[sk].append(row)
self.new_rows[sk].append(new_row)
put_request = PutRequest().set_value(row).set_table_name(
table_name).set_ttl(ttl)
self.versions[sk].append(
self.handle.put(put_request).get_version())
self.old_expect_expiration = ttl.to_expiration_time(
int(round(time() * 1000)))
self.ttl = TimeToLive.of_hours(1)
self.ops_sk = 0
illegal_sk = 1
self.requests.append(PutRequest().set_value(
self.new_rows[self.ops_sk][0]).set_table_name(table_name).set_ttl(
self.ttl).set_return_row(True))
self.requests.append(PutRequest().set_value(self.new_rows[
self.ops_sk][1]).set_table_name(table_name).set_option(
PutOption.IF_ABSENT).set_ttl(self.ttl).set_return_row(True))
self.requests.append(PutRequest().set_value(
self.new_rows[self.ops_sk][2]).set_use_table_default_ttl(
True).set_table_name(table_name).set_option(
PutOption.IF_PRESENT).set_return_row(True))
self.requests.append(PutRequest().set_value(
self.new_rows[self.ops_sk][3]).set_table_name(table_name).set_ttl(
self.ttl).set_option(PutOption.IF_VERSION).set_match_version(
self.versions[self.ops_sk][3]).set_return_row(True))
self.requests.append(DeleteRequest().set_key({
'fld_sid': self.ops_sk,
'fld_id': 4
}).set_table_name(table_name).set_return_row(True))
self.requests.append(DeleteRequest().set_key({
'fld_sid': self.ops_sk,
'fld_id': 5
}).set_table_name(table_name).set_return_row(True).set_match_version(
self.versions[self.ops_sk][0]))
self.illegal_requests.append(DeleteRequest().set_key({
'fld_sid': self.ops_sk,
'fld_id': 0
}).set_table_name('IllegalUsers'))
self.illegal_requests.append(DeleteRequest().set_key({
'fld_sid': illegal_sk,
'fld_id': 0
}).set_table_name(table_name))
self.write_multiple_request = WriteMultipleRequest().set_timeout(
timeout)
self.get_request = GetRequest().set_table_name(table_name)
self.hour_in_milliseconds = 60 * 60 * 1000
self.day_in_milliseconds = 24 * 60 * 60 * 1000