def test_str(self):
self.assertEqual(str(Duration(1, 1, 1)), "1mo1d1ns")
self.assertEqual(str(Duration(1, 1, -1)), "-1mo1d1ns")
self.assertEqual(str(Duration(1, 1, 1000000000000000)),
"1mo1d1000000000000000ns")
self.assertEqual(str(Duration(52, 23, 564564)), "52mo23d564564ns")
def test_smoke_duration_values(self):
"""
Test to write several Duration values to the database and verify
they can be read correctly. The verify than an exception is arisen
if the value is too big
@since 3.10
@jira_ticket PYTHON-747
@expected_result the read value in C* matches the written one
@test_category data_types serialization
"""
self.session.execute("""
CREATE TABLE duration_smoke (k int primary key, v duration)
""")
self.addCleanup(self.session.execute, "DROP TABLE duration_smoke")
prepared = self.session.prepare("""
INSERT INTO duration_smoke (k, v)
VALUES (?, ?)
""")
nanosecond_smoke_values = [
0, -1, 1, 100, 1000, 1000000, 1000000000, 10000000000000,
-9223372036854775807, 9223372036854775807,
int("7FFFFFFFFFFFFFFF", 16),
int("-7FFFFFFFFFFFFFFF", 16)
]
month_day_smoke_values = [
0, -1, 1, 100, 1000, 1000000, 1000000000,
int("7FFFFFFF", 16),
int("-7FFFFFFF", 16)
]
for nanosecond_value in nanosecond_smoke_values:
for month_day_value in month_day_smoke_values:
# Must have the same sign
if (month_day_value <= 0) != (nanosecond_value <= 0):
continue
self.session.execute(
prepared, (1,
Duration(month_day_value, month_day_value,
nanosecond_value)))
results = self.session.execute("SELECT * FROM duration_smoke")
v = results[0][1]
self.assertEqual(
Duration(month_day_value, month_day_value,
nanosecond_value), v,
"Error encoding value {0},{0},{1}".format(
month_day_value, nanosecond_value))
self.assertRaises(ValueError, self.session.execute, prepared,
(1, Duration(0, 0, int("8FFFFFFFFFFFFFF0", 16))))
self.assertRaises(ValueError, self.session.execute, prepared,
(1, Duration(0, int("8FFFFFFFFFFFFFF0", 16), 0)))
self.assertRaises(ValueError, self.session.execute, prepared,
(1, Duration(int("8FFFFFFFFFFFFFF0", 16), 0, 0)))
def test_set_service_level_timeouts(scylla_only, cql):
with new_service_level(cql) as sl:
cql.execute(f"ALTER SERVICE LEVEL {sl} WITH timeout = 575ms")
res = cql.execute(f"LIST SERVICE LEVEL {sl}")
assert res.one().timeout == Duration(0, 0, 575000000)
cql.execute(f"ALTER SERVICE LEVEL {sl} WITH timeout = 2h")
res = cql.execute(f"LIST SERVICE LEVEL {sl}")
assert res.one().timeout == Duration(0, 0, 2 * 60 * 60 * 10**9)
cql.execute(f"ALTER SERVICE LEVEL {sl} WITH timeout = null")
res = cql.execute(f"LIST SERVICE LEVEL {sl}")
assert not res.one().timeout
def test_batch(scylla_only, cql, table1):
table, _ = table1
key = random.randint(3, 2**60)
cql.execute(f"""BEGIN BATCH USING TIMEOUT 48h
INSERT INTO {table} (p,c,v) VALUES ({key},7,8);
INSERT INTO {table} (p,c,v) VALUES ({key+1},8,9);
APPLY BATCH
""")
result = list(cql.execute(f"SELECT * FROM {table} WHERE p = {key} and c = 7"))
assert len(result) == 1 and (result[0].c, result[0].v) == (7, 8)
result = list(cql.execute(f"SELECT * FROM {table} WHERE p = {key+1} and c = 8"))
assert len(result) == 1 and (result[0].c, result[0].v) == (8, 9)
prep1 = cql.prepare(f"""BEGIN BATCH USING TIMEOUT ?
INSERT INTO {table} (p,c,v) VALUES ({key},7,10);
INSERT INTO {table} (p,c,v) VALUES ({key+1},8,11);
APPLY BATCH
""")
prep2 = cql.prepare(f"""BEGIN BATCH USING TIMEOUT 48h
INSERT INTO {table} (p,c,v) VALUES (?,7,2);
INSERT INTO {table} (p,c,v) VALUES (?,?,14);
APPLY BATCH
""")
prep_named = cql.prepare(f"""BEGIN BATCH USING TIMEOUT :timeout
INSERT INTO {table} (p,c,v) VALUES (:key,7,8);
INSERT INTO {table} (p,c,v) VALUES ({key+1},8,:nine);
APPLY BATCH
""")
cql.execute(prep1, (Duration(nanoseconds=10**15),))
result = list(cql.execute(f"SELECT * FROM {table} WHERE p = {key} and c = 7"))
assert len(result) == 1 and (result[0].c, result[0].v) == (7, 10)
result = list(cql.execute(f"SELECT * FROM {table} WHERE p = {key+1} and c = 8"))
assert len(result) == 1 and (result[0].c, result[0].v) == (8, 11)
cql.execute(prep2, (key, key+1, 8))
result = list(cql.execute(f"SELECT * FROM {table} WHERE p = {key} and c = 7"))
assert len(result) == 1 and (result[0].c, result[0].v) == (7, 2)
result = list(cql.execute(f"SELECT * FROM {table} WHERE p = {key+1} and c = 8"))
assert len(result) == 1 and (result[0].c, result[0].v) == (8, 14)
cql.execute(prep_named, {'timeout': Duration(nanoseconds=10**15), 'key': key, 'nine': 9})
result = list(cql.execute(f"SELECT * FROM {table} WHERE p = {key} and c = 7"))
assert len(result) == 1 and (result[0].c, result[0].v) == (7,8)
result = list(cql.execute(f"SELECT * FROM {table} WHERE p = {key+1} and c = 8"))
assert len(result) == 1 and (result[0].c, result[0].v) == (8, 9)
with pytest.raises(WriteTimeout):
cql.execute(prep1, (Duration(nanoseconds=0),))
with pytest.raises(WriteTimeout):
cql.execute(prep_named, {'timeout': Duration(nanoseconds=0), 'key': key, 'nine': 9})
def test_prepared_statements(scylla_only, cql, table1):
table = table1
key = random.randint(3, 2**60)
prep = cql.prepare(
f"INSERT INTO {table} (p,c,v) VALUES ({key},6,7) USING TIMEOUT ?")
with pytest.raises(WriteTimeout):
cql.execute(prep, (Duration(nanoseconds=0), ))
cql.execute(prep, (Duration(nanoseconds=10**15), ))
result = list(cql.execute(f"SELECT * FROM {table} WHERE p = {key}"))
assert len(result) == 1 and (result[0].c, result[0].v) == (6, 7)
prep = cql.prepare(f"SELECT * FROM {table} USING TIMEOUT ?")
with pytest.raises(ReadTimeout):
cql.execute(prep, (Duration(nanoseconds=0), ))
cql.execute(prep, (Duration(nanoseconds=10**15), ))
prep = cql.prepare(
f"UPDATE {table} USING TIMEOUT ? AND TIMESTAMP ? SET v = ? WHERE p = {key} and c = 1"
)
with pytest.raises(WriteTimeout):
cql.execute(prep, (Duration(nanoseconds=0), 3, 42))
cql.execute(prep, (Duration(nanoseconds=10**15), 3, 42))
prep_named = cql.prepare(
f"UPDATE {table} USING TIMEOUT :timeout AND TIMESTAMP :ts SET v = :v WHERE p = {key} and c = 1"
)
# Timeout cannot be left unbound
with pytest.raises(InvalidRequest):
cql.execute(prep_named, {'timestamp': 42, 'v': 3})
cql.execute(prep_named, {
'timestamp': 42,
'v': 3,
'timeout': Duration(nanoseconds=10**15)
})
result = list(
cql.execute(f"SELECT * FROM {table} WHERE p = {key} AND c = 1"))
assert len(result) == 1 and (result[0].c, result[0].v) == (1, 3)
def test_equality(self):
first = Duration(1, 1, 1)
second = Duration(-1, 1, 1)
self.assertNotEqual(first, second)
first = Duration(1, 1, 1)
second = Duration(1, 1, 1)
self.assertEqual(first, second)
first = Duration()
second = Duration(0, 0, 0)
self.assertEqual(first, second)
first = Duration(1000, 10000, 2345345)
second = Duration(1000, 10000, 2345345)
self.assertEqual(first, second)
first = Duration(12, 0, 100)
second = Duration(nanoseconds=100, months=12)
self.assertEqual(first, second)
def test_valid_format(self):
valid = Duration(1, 1, 1)
self.assertEqual(valid.months, 1)
self.assertEqual(valid.days, 1)
self.assertEqual(valid.nanoseconds, 1)
valid = Duration(nanoseconds=100000)
self.assertEqual(valid.months, 0)
self.assertEqual(valid.days, 0)
self.assertEqual(valid.nanoseconds, 100000)
valid = Duration()
self.assertEqual(valid.months, 0)
self.assertEqual(valid.days, 0)
self.assertEqual(valid.nanoseconds, 0)
valid = Duration(-10, -21, -1000)
self.assertEqual(valid.months, -10)
self.assertEqual(valid.days, -21)
self.assertEqual(valid.nanoseconds, -1000)
def deserialize(cls, value, reader=None):
return Duration(
reader.deserialize(value['months']),
reader.deserialize(value['days']),
reader.deserialize(value['nanos'])
)
def test_type_duration_human_readable_input_units(cql, table1):
# Map of allowed units and their expected meaning.
units = {
'y': Duration(12, 0, 0),
'mo': Duration(1, 0, 0),
'w': Duration(0, 7, 0),
'd': Duration(0, 1, 0),
'h': Duration(0, 0, 3600000000000),
'm': Duration(0, 0, 60000000000),
's': Duration(0, 0, 1000000000),
'ms': Duration(0, 0, 1000000),
'us': Duration(0, 0, 1000),
'ns': Duration(0, 0, 1),
# An alias for "us" which should be supported, but wasn't (issue #8001)
'µs': Duration(0, 0, 1000),
}
p = random.randint(1,1000000000)
for (unit, duration) in units.items():
print(unit)
cql.execute(f"INSERT INTO {table1} (p, d) VALUES ({p}, 1{unit})")
assert list(cql.execute(f"SELECT d FROM {table1} where p = {p}")) == [(duration,)]
def get_sample_data():
sample_data = {}
for datatype in PRIMITIVE_DATATYPES:
if datatype == 'ascii':
sample_data[datatype] = 'ascii'
elif datatype == 'bigint':
sample_data[datatype] = 2**63 - 1
elif datatype == 'blob':
sample_data[datatype] = bytearray(b'hello world')
elif datatype == 'boolean':
sample_data[datatype] = True
elif datatype == 'decimal':
sample_data[datatype] = Decimal('12.3E+7')
elif datatype == 'double':
sample_data[datatype] = 1.23E+8
elif datatype == 'float':
sample_data[datatype] = 3.4028234663852886e+38
elif datatype == 'inet':
sample_data[datatype] = '123.123.123.123'
elif datatype == 'int':
sample_data[datatype] = 2147483647
elif datatype == 'text':
sample_data[datatype] = 'text'
elif datatype == 'timestamp':
sample_data[datatype] = datetime(2013, 12, 31, 23, 59, 59, 999000)
elif datatype == 'timeuuid':
sample_data[datatype] = uuid1()
elif datatype == 'uuid':
sample_data[datatype] = uuid4()
elif datatype == 'varchar':
sample_data[datatype] = 'varchar'
elif datatype == 'varint':
sample_data[datatype] = int(str(2147483647) + '000')
elif datatype == 'date':
sample_data[datatype] = Date(date(2015, 1, 15))
elif datatype == 'time':
sample_data[datatype] = Time(time(16, 47, 25, 7))
elif datatype == 'tinyint':
sample_data[datatype] = 123
elif datatype == 'smallint':
sample_data[datatype] = 32523
elif datatype == 'duration':
sample_data[datatype] = Duration(months=2,
days=12,
nanoseconds=21231)
else:
raise Exception("Missing handling of {0}".format(datatype))
return sample_data
def test_can_insert_model_with_all_column_types(self):
"""
Test for inserting all column types into a Model
test_can_insert_model_with_all_column_types tests that each cqlengine column type can be inserted into a Model.
It first creates a Model that has each cqlengine column type. It then creates a Model instance where all the fields
have corresponding data, which performs the insert into the Cassandra table.
Finally, it verifies that each column read from the Model from Cassandra is the same as the input parameters.
@since 2.6.0
@jira_ticket PYTHON-246
@expected_result The Model is inserted with each column type, and the resulting read yields proper data for each column.
@test_category data_types:primitive
"""
class AllDatatypesModel(Model):
id = columns.Integer(primary_key=True)
a = columns.Ascii()
b = columns.BigInt()
c = columns.Blob()
d = columns.Boolean()
e = columns.DateTime()
f = columns.Decimal()
g = columns.Double()
h = columns.Float()
i = columns.Inet()
j = columns.Integer()
k = columns.Text()
l = columns.TimeUUID()
m = columns.UUID()
n = columns.VarInt()
o = columns.Duration()
sync_table(AllDatatypesModel)
input = [
'ascii', 2**63 - 1,
bytearray(b'hello world'), True,
datetime.utcfromtimestamp(872835240),
Decimal('12.3E+7'), 2.39, 3.4028234663852886e+38,
'123.123.123.123', 2147483647, 'text',
UUID('FE2B4360-28C6-11E2-81C1-0800200C9A66'),
UUID('067e6162-3b6f-4ae2-a171-2470b63dff00'),
int(str(2147483647) + '000')
]
AllDatatypesModel.create(
id=0,
a='ascii',
b=2**63 - 1,
c=bytearray(b'hello world'),
d=True,
e=datetime.utcfromtimestamp(872835240),
f=Decimal('12.3E+7'),
g=2.39,
h=3.4028234663852886e+38,
i='123.123.123.123',
j=2147483647,
k='text',
l=UUID('FE2B4360-28C6-11E2-81C1-0800200C9A66'),
m=UUID('067e6162-3b6f-4ae2-a171-2470b63dff00'),
n=int(str(2147483647) + '000'),
o=Duration(2, 3, 4))
self.assertEqual(1, AllDatatypesModel.objects.count())
output = AllDatatypesModel.objects.first()
for i, i_char in enumerate(range(ord('a'), ord('a') + 14)):
self.assertEqual(input[i], output[chr(i_char)])