def table_test(self):
"""
CREATE TABLE, ALTER TABLE, TRUNCATE TABLE, DROP TABLE statements
"""
session = self.prepare()
session.execute("CREATE TABLE test1 (k int PRIMARY KEY, v1 int)")
session.execute("CREATE TABLE test2 (k int, c1 int, v1 int, PRIMARY KEY (k, c1)) WITH COMPACT STORAGE")
session.execute("ALTER TABLE test1 ADD v2 int")
for i in xrange(0, 10):
session.execute("INSERT INTO test1 (k, v1, v2) VALUES (%d, %d, %d)" % (i, i, i))
session.execute("INSERT INTO test2 (k, c1, v1) VALUES (%d, %d, %d)" % (i, i, i))
res = sorted(session.execute("SELECT * FROM test1"))
assert rows_to_list(res) == [[i, i, i] for i in xrange(0, 10)], res
res = sorted(session.execute("SELECT * FROM test2"))
assert rows_to_list(res) == [[i, i, i] for i in xrange(0, 10)], res
session.execute("TRUNCATE test1")
session.execute("TRUNCATE test2")
res = session.execute("SELECT * FROM test1")
assert rows_to_list(res) == [], res
res = session.execute("SELECT * FROM test2")
assert rows_to_list(res) == [], res
session.execute("DROP TABLE test1")
session.execute("DROP TABLE test2")
assert_invalid(session, "SELECT * FROM test1", expected=InvalidRequest)
assert_invalid(session, "SELECT * FROM test2", expected=InvalidRequest)
def table_test(self):
"""
CREATE TABLE, ALTER TABLE, TRUNCATE TABLE, DROP TABLE statements
"""
session = self.prepare()
session.execute("CREATE TABLE test1 (k int PRIMARY KEY, v1 int)")
session.execute("CREATE TABLE test2 (k int, c1 int, v1 int, PRIMARY KEY (k, c1)) WITH COMPACT STORAGE")
session.execute("ALTER TABLE test1 ADD v2 int")
for i in xrange(0, 10):
session.execute("INSERT INTO test1 (k, v1, v2) VALUES (%d, %d, %d)" % (i, i, i))
session.execute("INSERT INTO test2 (k, c1, v1) VALUES (%d, %d, %d)" % (i, i, i))
res = sorted(session.execute("SELECT * FROM test1"))
assert rows_to_list(res) == [[i, i, i] for i in xrange(0, 10)], res
res = sorted(session.execute("SELECT * FROM test2"))
assert rows_to_list(res) == [[i, i, i] for i in xrange(0, 10)], res
session.execute("TRUNCATE test1")
session.execute("TRUNCATE test2")
res = session.execute("SELECT * FROM test1")
assert rows_to_list(res) == [], res
res = session.execute("SELECT * FROM test2")
assert rows_to_list(res) == [], res
session.execute("DROP TABLE test1")
session.execute("DROP TABLE test2")
assert_invalid(session, "SELECT * FROM test1", expected=InvalidRequest)
assert_invalid(session, "SELECT * FROM test2", expected=InvalidRequest)
def test_multi_index_filtering_query(self):
"""
asserts that having multiple indexes that cover all predicates still requires ALLOW FILTERING to also be present
"""
cluster = self.cluster
cluster.populate(1).start()
node1, = cluster.nodelist()
session = self.patient_cql_connection(node1)
session.execute("CREATE KEYSPACE ks WITH REPLICATION = {'class': 'SimpleStrategy', 'replication_factor': '1'};")
session.execute("USE ks;")
session.execute("CREATE TABLE tbl (id uuid primary key, c0 text, c1 text, c2 text);")
session.execute("CREATE INDEX ix_tbl_c0 ON tbl(c0);")
session.execute("CREATE INDEX ix_tbl_c1 ON tbl(c1);")
session.execute("INSERT INTO tbl (id, c0, c1, c2) values (uuid(), 'a', 'b', 'c');")
session.execute("INSERT INTO tbl (id, c0, c1, c2) values (uuid(), 'a', 'b', 'c');")
session.execute("INSERT INTO tbl (id, c0, c1, c2) values (uuid(), 'q', 'b', 'c');")
session.execute("INSERT INTO tbl (id, c0, c1, c2) values (uuid(), 'a', 'e', 'f');")
session.execute("INSERT INTO tbl (id, c0, c1, c2) values (uuid(), 'a', 'e', 'f');")
rows = list(session.execute("SELECT * FROM tbl WHERE c0 = 'a';"))
self.assertEqual(4, len(rows))
stmt = "SELECT * FROM tbl WHERE c0 = 'a' AND c1 = 'b';"
assert_invalid(session, stmt, "Cannot execute this query as it might involve data filtering and thus may have "
"unpredictable performance. If you want to execute this query despite the "
"performance unpredictability, use ALLOW FILTERING")
rows = list(session.execute("SELECT * FROM tbl WHERE c0 = 'a' AND c1 = 'b' ALLOW FILTERING;"))
self.assertEqual(2, len(rows))
def udf_with_udt_keyspace_isolation_test(self):
"""
Ensure functions dont allow a UDT from another keyspace
@jira_ticket CASSANDRA-9409
@since 2.2
"""
session = self.prepare()
session.execute("create type udt (a text, b int);")
self.create_ks(session, 'user_ks', 1)
# ensure we cannot use a udt from another keyspace as function argument
assert_invalid(
session,
"CREATE FUNCTION overloaded(v ks.udt) called on null input RETURNS text LANGUAGE java AS 'return \"f1\";'",
"Statement on keyspace user_ks cannot refer to a user type in keyspace ks"
)
# ensure we cannot use a udt from another keyspace as return value
assert_invalid(
session,
("CREATE FUNCTION test(v text) called on null input RETURNS ks.udt "
"LANGUAGE java AS 'return null;';"),
"Statement on keyspace user_ks cannot refer to a user type in keyspace ks"
)
def invalid_string_literals_test(self):
"""
@jira_ticket CASSANDRA-8101
- assert INSERTing into a nonexistent table fails normally, with an InvalidRequest exception
- create a table with ascii and text columns
- assert that trying to execute an insert statement with non-UTF8 contents raises a ProtocolException
- tries to insert into a nonexistent column to make sure the ProtocolException is raised over other errors
"""
session = self.prepare()
# this should fail as normal, not with a ProtocolException
assert_invalid(
session,
u"insert into invalid_string_literals (k, a) VALUES (0, '\u038E\u0394\u03B4\u03E0')"
)
session = self.cql_connection(self.cluster.nodelist()[0],
keyspace='ks')
session.execute(
"create table invalid_string_literals (k int primary key, a ascii, b text)"
)
# this should still fail with an InvalidRequest
assert_invalid(
session,
u"insert into invalid_string_literals (k, c) VALUES (0, '\u038E\u0394\u03B4\u03E0')"
)
# but since the protocol requires strings to be valid UTF-8, the error
# response to this is a ProtocolException, not an error about the
# nonexistent column
with self.assertRaisesRegexp(ProtocolException,
'Cannot decode string as UTF8'):
session.execute(
"insert into invalid_string_literals (k, c) VALUES (0, '\xc2\x01')"
)
def altering_nonexistent_user_throws_exception_test(self):
self.prepare()
session = self.get_session(user='******', password='******')
assert_invalid(
session, "ALTER USER nonexistent WITH PASSWORD 'doesn''tmatter'",
"nonexistent doesn't exist")
def keyspace_test(self):
"""
Smoke test that basic keyspace operations work:
- create a keyspace
- USE that keyspace
- ALTER it
- #TODO: assert the ALTER worked
- DROP it
- attempt to USE it again, asserting it raises an InvalidRequest exception
"""
session = self.prepare(create_keyspace=False)
session.execute("CREATE KEYSPACE ks WITH replication = "
"{ 'class':'SimpleStrategy', 'replication_factor':1} "
"AND DURABLE_WRITES = true")
session.execute("USE ks")
session.execute("ALTER KEYSPACE ks WITH replication = "
"{ 'class' : 'NetworkTopologyStrategy', 'dc1' : 1 } "
"AND DURABLE_WRITES = false")
session.execute("DROP KEYSPACE ks")
assert_invalid(session, "USE ks", expected=InvalidRequest)
def index_test(self):
"""
Smoke test CQL statements related to indexes:
- CREATE a table
- CREATE an index on that table
- INSERT 10 values into the table
- SELECT from the table over the indexed value and assert the expected values come back
- drop the index
- assert SELECTing over the indexed value raises an InvalidRequest
# TODO run SELECTs to make sure each statement works
"""
session = self.prepare()
session.execute("CREATE TABLE test3 (k int PRIMARY KEY, v1 int, v2 int)")
session.execute("CREATE INDEX testidx ON test3 (v1)")
for i in range(0, 10):
session.execute("INSERT INTO test3 (k, v1, v2) VALUES ({i}, {i}, {i})".format(i=i))
res = session.execute("SELECT * FROM test3 WHERE v1 = 0")
self.assertEqual(rows_to_list(res), [[0, 0, 0]])
session.execute("DROP INDEX testidx")
assert_invalid(session, "SELECT * FROM test3 where v1 = 0", expected=InvalidRequest)
def type_test(self):
"""
Smoke test basic TYPE operations:
- CREATE a type
- CREATE a table using that type
- ALTER the type and CREATE another table
- DROP the tables and type
- CREATE another table using the DROPped type and assert it fails with an InvalidRequest
# TODO run SELECTs to make sure each statement works
# TODO is this even necessary given the existence of the auth_tests?
"""
session = self.prepare()
session.execute("CREATE TYPE address_t (street text, city text, zip_code int)")
session.execute("CREATE TABLE test4 (id int PRIMARY KEY, address frozen<address_t>)")
session.execute("ALTER TYPE address_t ADD phones set<text>")
session.execute("CREATE TABLE test5 (id int PRIMARY KEY, address frozen<address_t>)")
session.execute("DROP TABLE test4")
session.execute("DROP TABLE test5")
session.execute("DROP TYPE address_t")
assert_invalid(session,
"CREATE TABLE test6 (id int PRIMARY KEY, address frozen<address_t>)",
expected=InvalidRequest)
def validate_empty_column_name_test(self):
cluster = self.cluster
cluster.populate(1).start()
node1 = cluster.nodelist()[0]
session = self.patient_cql_connection(node1)
self.create_ks(session, 'counter_tests', 1)
session.execute("""
CREATE TABLE compact_counter_table (
pk int,
ck text,
value counter,
PRIMARY KEY (pk, ck))
WITH COMPACT STORAGE
""")
assert_invalid(
session,
"UPDATE compact_counter_table SET value = value + 1 WHERE pk = 0 AND ck = ''"
)
assert_invalid(
session,
"UPDATE compact_counter_table SET value = value - 1 WHERE pk = 0 AND ck = ''"
)
session.execute(
"UPDATE compact_counter_table SET value = value + 5 WHERE pk = 0 AND ck = 'ck'"
)
session.execute(
"UPDATE compact_counter_table SET value = value - 2 WHERE pk = 0 AND ck = 'ck'"
)
assert_one(session, "SELECT pk, ck, value FROM compact_counter_table",
[0, 'ck', 3])
def aggregate_udf_test(self):
session = self.prepare()
session.execute("create table nums (key int primary key, val int);")
for x in range(1, 4):
session.execute("INSERT INTO nums (key, val) VALUES (%d, %d)" %
(x, x))
session.execute(
"create function plus(key int, val int) called on null input returns int language java as 'return Integer.valueOf(key.intValue() + val.intValue());'"
)
session.execute(
"create function stri(key int) called on null input returns text language java as 'return key.toString();'"
)
session.execute(
"create aggregate suma (int) sfunc plus stype int finalfunc stri initcond 10"
)
assert_one(session, "select suma(val) from nums", ["16"])
session.execute(
"create function test(a int, b double) called on null input returns int language javascript as 'a + b;'"
)
session.execute("create aggregate aggy(double) sfunc test stype int")
assert_invalid(session,
"create aggregate aggtwo(int) sfunc aggy stype int")
assert_invalid(
session,
"create aggregate aggthree(int) sfunc test stype int finalfunc aggtwo"
)
def udf_with_udt_keyspace_isolation_test(self):
"""
Ensure functions dont allow a UDT from another keyspace
@jira_ticket CASSANDRA-9409
@since 2.2
"""
session = self.prepare()
session.execute("create type udt (a text, b int);")
self.create_ks(session, 'user_ks', 1)
# ensure we cannot use a udt from another keyspace as function argument
assert_invalid(
session,
"CREATE FUNCTION overloaded(v ks.udt) called on null input RETURNS text LANGUAGE java AS 'return \"f1\";'",
"Statement on keyspace user_ks cannot refer to a user type in keyspace ks"
)
# ensure we cannot use a udt from another keyspace as return value
assert_invalid(
session,
("CREATE FUNCTION test(v text) called on null input RETURNS ks.udt "
"LANGUAGE java AS 'return null;';"),
"Statement on keyspace user_ks cannot refer to a user type in keyspace ks"
)
def allow_filtering_test(self):
"""Test that allow filtering works as usual for a materialized view"""
session = self.prepare()
session.execute("CREATE TABLE t (id int PRIMARY KEY, v int, v2 text, v3 decimal)")
session.execute(("CREATE MATERIALIZED VIEW t_by_v AS SELECT * FROM t "
"WHERE v IS NOT NULL AND id IS NOT NULL PRIMARY KEY (v, id)"))
session.execute(("CREATE MATERIALIZED VIEW t_by_v2 AS SELECT * FROM t "
"WHERE v2 IS NOT NULL AND id IS NOT NULL PRIMARY KEY (v2, id)"))
for i in xrange(1000):
session.execute("INSERT INTO t (id, v, v2, v3) VALUES ({v}, {v}, 'a', 3.0)".format(v=i))
for i in xrange(1000):
assert_one(session, "SELECT * FROM t_by_v WHERE v = {v}".format(v=i), [i, i, 'a', 3.0])
rows = session.execute("SELECT * FROM t_by_v2 WHERE v2 = 'a'")
self.assertEqual(len(rows), 1000, "Expected 1000 rows but got {}".format(len(rows)))
assert_invalid(session, "SELECT * FROM t_by_v WHERE v = 1 AND v2 = 'a'")
assert_invalid(session, "SELECT * FROM t_by_v2 WHERE v2 = 'a' AND v = 1")
for i in xrange(1000):
assert_one(
session,
"SELECT * FROM t_by_v WHERE v = {} AND v3 = 3.0 ALLOW FILTERING".format(i),
[i, i, 'a', 3.0]
)
assert_one(
session,
"SELECT * FROM t_by_v2 WHERE v2 = 'a' AND v = {} ALLOW FILTERING".format(i),
['a', i, i, 3.0]
)
def test_multi_index_filtering_query(self):
"""
asserts that having multiple indexes that cover all predicates still requires ALLOW FILTERING to also be present
"""
cluster = self.cluster
cluster.populate(1).start()
node1, = cluster.nodelist()
session = self.patient_cql_connection(node1)
session.execute("CREATE KEYSPACE ks WITH REPLICATION = {'class': 'SimpleStrategy', 'replication_factor': '1'};")
session.execute("USE ks;")
session.execute("CREATE TABLE tbl (id uuid primary key, c0 text, c1 text, c2 text);")
session.execute("CREATE INDEX ix_tbl_c0 ON tbl(c0);")
session.execute("CREATE INDEX ix_tbl_c1 ON tbl(c1);")
session.execute("INSERT INTO tbl (id, c0, c1, c2) values (uuid(), 'a', 'b', 'c');")
session.execute("INSERT INTO tbl (id, c0, c1, c2) values (uuid(), 'a', 'b', 'c');")
session.execute("INSERT INTO tbl (id, c0, c1, c2) values (uuid(), 'q', 'b', 'c');")
session.execute("INSERT INTO tbl (id, c0, c1, c2) values (uuid(), 'a', 'e', 'f');")
session.execute("INSERT INTO tbl (id, c0, c1, c2) values (uuid(), 'a', 'e', 'f');")
rows = list(session.execute("SELECT * FROM tbl WHERE c0 = 'a';"))
self.assertEqual(4, len(rows))
stmt = "SELECT * FROM tbl WHERE c0 = 'a' AND c1 = 'b';"
assert_invalid(session, stmt, "Cannot execute this query as it might involve data filtering and thus may have "
"unpredictable performance. If you want to execute this query despite the "
"performance unpredictability, use ALLOW FILTERING")
rows = list(session.execute("SELECT * FROM tbl WHERE c0 = 'a' AND c1 = 'b' ALLOW FILTERING;"))
self.assertEqual(2, len(rows))
def udf_with_udt_test(self):
"""
Test UDFs that operate on non-frozen UDTs.
@jira_ticket CASSANDRA-7423
@since 3.6
"""
session = self.prepare()
session.execute("create type test (a text, b int);")
session.execute("create function funk(udt test) called on null input returns int language java as 'return Integer.valueOf(udt.getInt(\"b\"));';")
if LooseVersion(self.cluster.version()) >= LooseVersion('3.6'):
frozen_vals = (False, True)
else:
frozen_vals = (True,)
for frozen in frozen_vals:
debug("Using {} UDTs".format("frozen" if frozen else "non-frozen"))
table_name = "tab_frozen" if frozen else "tab"
column_type = "frozen<test>" if frozen else "test"
session.execute("create table {} (key int primary key, udt {});".format(table_name, column_type))
session.execute("insert into %s (key, udt) values (1, {a: 'un', b:1});" % (table_name,))
session.execute("insert into %s (key, udt) values (2, {a: 'deux', b:2});" % (table_name,))
session.execute("insert into %s (key, udt) values (3, {a: 'trois', b:3});" % (table_name,))
assert_one(session, "select sum(funk(udt)) from {}".format(table_name), [6])
assert_invalid(session, "drop type test;")
def check_permissions(self, node, upgraded):
# use an exclusive connection to ensure we only talk to the specified node
klaus = self.patient_exclusive_cql_connection(node, user='******', password='******', timeout=20)
# klaus is a superuser, so should be able to list all permissions
# the output of LIST PERMISSIONS changes slightly with #7653 adding
# a new role column to results, so we need to tailor our check
# based on whether the node has been upgraded or not
if not upgraded:
assert_all(klaus,
'LIST ALL PERMISSIONS',
[['michael', '<table ks.cf1>', 'MODIFY'],
['michael', '<table ks.cf2>', 'SELECT']])
else:
assert_all(klaus,
'LIST ALL PERMISSIONS',
[['michael', 'michael', '<table ks.cf1>', 'MODIFY'],
['michael', 'michael', '<table ks.cf2>', 'SELECT']])
klaus.shutdown()
michael = self.patient_exclusive_cql_connection(node, user='******', password='******')
michael.execute('INSERT INTO ks.cf1 (id, val) VALUES (0,0)')
michael.execute('SELECT * FROM ks.cf2')
assert_invalid(michael,
'SELECT * FROM ks.cf1',
'User michael has no SELECT permission on <table ks.cf1> or any of its parents',
Unauthorized)
michael.shutdown()
def drop_column_compact_test(self):
session = self.prepare()
session.execute("USE ks")
session.execute("CREATE TABLE cf (key int PRIMARY KEY, c1 int, c2 int) WITH COMPACT STORAGE")
assert_invalid(session, "ALTER TABLE cf DROP c1", "Cannot drop columns from a")
def drop_table_test(self):
"""Test that we cannot drop a table without deleting its MVs first"""
session = self.prepare(user_table=True)
result = session.execute(("SELECT * FROM system_schema.materialized_views "
"WHERE keyspace_name='ks' AND table_name='users'"))
self.assertEqual(
len(result), 1,
"Expecting {} materialized view, got {}".format(1, len(result))
)
assert_invalid(
session,
"DROP TABLE ks.users;",
"Cannot drop table when materialized views still depend on it"
)
result = session.execute(("SELECT * FROM system_schema.materialized_views "
"WHERE keyspace_name='ks' AND table_name='users'"))
self.assertEqual(
len(result), 1,
"Expecting {} materialized view, got {}".format(1, len(result))
)
session.execute("DROP MATERIALIZED VIEW ks.users_by_state;")
session.execute("DROP TABLE ks.users;")
result = session.execute(("SELECT * FROM system_schema.materialized_views "
"WHERE keyspace_name='ks' AND table_name='users'"))
self.assertEqual(
len(result), 0,
"Expecting {} materialized view, got {}".format(1, len(result))
)
def range_request_failure_query():
assert_invalid(
session,
SimpleStatement("select * from test",
consistency_level=CL.ALL),
expected=ReadTimeout
if self.cluster.version() < '3' else ReadFailure,
)
def read_failure_query():
assert_invalid(
session,
SimpleStatement("select * from test where id in (1,2,3,4,5)",
consistency_level=CL.ALL),
expected=ReadTimeout
if self.cluster.version() < '3' else ReadFailure,
)
def test_type_as_part_of_pkey(self):
"""Tests user types as part of a composite pkey"""
# make sure we can define a table with a user type as part of the pkey
# and do a basic insert/query of data in that table.
cluster = self.cluster
cluster.populate(3).start()
node1, node2, node3 = cluster.nodelist()
session = self.patient_cql_connection(node1)
self.create_ks(session, 'user_type_pkeys', 2)
session.default_consistency_level = ConsistencyLevel.LOCAL_QUORUM
stmt = """
CREATE TYPE t_person_name (
first text,
middle text,
last text
)
"""
session.execute(stmt)
stmt = """
CREATE TABLE person_likes (
id uuid,
name frozen<t_person_name>,
like text,
PRIMARY KEY ((id, name))
)
"""
session.execute(stmt)
# Make sure the schema propagate
time.sleep(2)
_id = uuid.uuid4()
stmt = """
INSERT INTO person_likes (id, name, like)
VALUES ({id}, {{first:'Nero', middle:'Claudius Caesar Augustus', last:'Germanicus'}}, 'arson');
""".format(id=_id)
session.execute(stmt)
# attempt to query without the user type portion of the pkey and confirm there is an error
stmt = """
SELECT id, name.first from person_likes where id={id};
""".format(id=_id)
if self.cluster.version() >= '2.2':
assert_invalid(session, stmt, 'Partition key parts: name must be restricted as other parts are')
else:
assert_invalid(session, stmt, 'Partition key part name must be restricted since preceding part is')
stmt = """
SELECT id, name.first, like from person_likes where id={id} and name = {{first:'Nero', middle: 'Claudius Caesar Augustus', last: 'Germanicus'}};
""".format(id=_id)
rows = session.execute(stmt)
row_uuid, first_name, like = rows[0]
self.assertEqual(first_name, u'Nero')
self.assertEqual(like, u'arson')
def assertions_test(self):
# assert_exception_test
mock_session = Mock(
**
{'execute.side_effect': AlreadyExists("Dummy exception message.")})
assert_exception(mock_session, "DUMMY QUERY", expected=AlreadyExists)
# assert_unavailable_test
mock_session = Mock(**{
'execute.side_effect':
Unavailable("Dummy Unavailabile message.")
})
assert_unavailable(mock_session.execute)
# assert_invalid_test
mock_session = Mock(**{
'execute.side_effect':
InvalidRequest("Dummy InvalidRequest message.")
})
assert_invalid(mock_session, "DUMMY QUERY")
# assert_unauthorized_test
mock_session = Mock(**{
'execute.side_effect':
Unauthorized("Dummy Unauthorized message.")
})
assert_unauthorized(mock_session, "DUMMY QUERY", None)
# assert_one_test
mock_session = Mock()
mock_session.execute = Mock(return_value=[[1, 1]])
assert_one(mock_session, "SELECT * FROM test", [1, 1])
# assert_none_test
mock_session = Mock()
mock_session.execute = Mock(return_value=[])
assert_none(mock_session, "SELECT * FROM test")
# assert_all_test
mock_session = Mock()
mock_session.execute = Mock(return_value=[[i, i]
for i in range(0, 10)])
assert_all(mock_session,
"SELECT k, v FROM test", [[i, i] for i in range(0, 10)],
ignore_order=True)
# assert_almost_equal_test
assert_almost_equal(1, 1.1, 1.2, 1.9, error=1.0)
# assert_row_count_test
mock_session = Mock()
mock_session.execute = Mock(return_value=[[1]])
assert_row_count(mock_session, 'test', 1)
# assert_length_equal_test
check = [1, 2, 3, 4]
assert_length_equal(check, 4)
def user_cant_drop_themselves_test(self):
self.prepare()
session = self.get_session(user='******', password='******')
# handle different error messages between versions pre and post 2.2.0
assert_invalid(
session, "DROP USER cassandra",
"(Users aren't allowed to DROP themselves|Cannot DROP primary role for current login)"
)
def only_one_timestamp_is_valid_test(self):
""" Test that TIMESTAMP must not be used in the statements within the batch. """
session = self.prepare()
assert_invalid(session, """
BEGIN BATCH USING TIMESTAMP 1111111111111111
INSERT INTO users (id, firstname, lastname) VALUES (0, 'Jack', 'Sparrow') USING TIMESTAMP 2
INSERT INTO users (id, firstname, lastname) VALUES (1, 'Will', 'Turner')
APPLY BATCH
""", matching="Timestamp must be set either on BATCH or individual statements")
def unlogged_batch_rejects_counter_mutations_test(self):
""" Test that unlogged batch rejects counter mutations """
cursor = self.prepare()
assert_invalid(cursor, """
BEGIN UNLOGGED BATCH
INSERT INTO users (id, firstname, lastname) VALUES (0, 'Jack', 'Sparrow')
INSERT INTO users (id, firstname, lastname) VALUES (2, 'Elizabeth', 'Swann')
UPDATE clicks SET total = total + 1 WHERE userid = 1 AND url = 'http://foo.com'
APPLY BATCH
""", matching="Counter mutations are only allowed in COUNTER batches")
def cant_create_existing_user_test(self):
self.prepare()
session = self.get_session(user="******", password="******")
session.execute("CREATE USER '*****@*****.**' WITH PASSWORD '12345' NOSUPERUSER")
assert_invalid(
session,
"CREATE USER '*****@*****.**' WITH PASSWORD '12345' NOSUPERUSER",
"[email protected] already exists",
)
def user_cant_drop_themselves_test(self):
self.prepare()
session = self.get_session(user="******", password="******")
# handle different error messages between versions pre and post 2.2.0
assert_invalid(
session,
"DROP USER cassandra",
"(Users aren't allowed to DROP themselves|Cannot DROP primary role for current login)",
)
def drop_column_compact_test(self):
session = self.prepare()
session.execute("USE ks")
session.execute(
"CREATE TABLE cf (key int PRIMARY KEY, c1 int, c2 int) WITH COMPACT STORAGE"
)
assert_invalid(session, "ALTER TABLE cf DROP c1",
"Cannot drop columns from a")
def test_multiple_indexes_on_single_map_column(self):
"""
verifying functionality of multiple unique secondary indexes on a single column
@jira_ticket CASSANDRA-7771
@since 3.0
"""
cluster = self.cluster
cluster.populate(1).start()
[node1] = cluster.nodelist()
session = self.patient_cql_connection(node1)
self.create_ks(session, "map_double_index", 1)
session.execute(
"""
CREATE TABLE map_tbl (
id uuid primary key,
amap map<text, int>
)
"""
)
session.execute("CREATE INDEX map_keys ON map_tbl(keys(amap))")
session.execute("CREATE INDEX map_values ON map_tbl(amap)")
session.execute("CREATE INDEX map_entries ON map_tbl(entries(amap))")
# multiple indexes on a single column are allowed but identical duplicate indexes are not
assert_invalid(
session,
"CREATE INDEX map_values_2 ON map_tbl(amap)",
"Index map_values_2 is a duplicate of existing index map_values",
)
session.execute("INSERT INTO map_tbl (id, amap) values (uuid(), {'foo': 1, 'bar': 2});")
session.execute("INSERT INTO map_tbl (id, amap) values (uuid(), {'faz': 1, 'baz': 2});")
value_search = session.execute("SELECT * FROM map_tbl WHERE amap CONTAINS 1")
self.assertEqual(2, len(value_search), "incorrect number of rows when querying on map values")
key_search = session.execute("SELECT * FROM map_tbl WHERE amap CONTAINS KEY 'foo'")
self.assertEqual(1, len(key_search), "incorrect number of rows when querying on map keys")
entries_search = session.execute("SELECT * FROM map_tbl WHERE amap['foo'] = 1")
self.assertEqual(1, len(entries_search), "incorrect number of rows when querying on map entries")
session.cluster.refresh_schema_metadata()
table_meta = session.cluster.metadata.keyspaces["map_double_index"].tables["map_tbl"]
self.assertEqual(3, len(table_meta.indexes))
self.assertItemsEqual(["map_keys", "map_values", "map_entries"], table_meta.indexes)
self.assertEqual(3, len(session.cluster.metadata.keyspaces["map_double_index"].indexes))
self.assertTrue("map_keys" in table_meta.export_as_string())
self.assertTrue("map_values" in table_meta.export_as_string())
self.assertTrue("map_entries" in table_meta.export_as_string())
session.execute("DROP TABLE map_tbl")
session.cluster.refresh_schema_metadata()
self.assertEqual(0, len(session.cluster.metadata.keyspaces["map_double_index"].indexes))
def counter_batch_rejects_regular_mutations_test(self):
""" Test that counter batch rejects non-counter mutations """
cursor = self.prepare()
assert_invalid(cursor, """
BEGIN COUNTER BATCH
UPDATE clicks SET total = total + 1 WHERE userid = 1 and url = 'http://foo.com'
UPDATE clicks SET total = total + 1 WHERE userid = 1 and url = 'http://bar.com'
UPDATE clicks SET total = total + 1 WHERE userid = 2 and url = 'http://baz.com'
INSERT INTO users (id, firstname, lastname) VALUES (0, 'Jack', 'Sparrow')
APPLY BATCH
""", matching="Only counter mutations are allowed in COUNTER batches")
def cant_create_existing_user_test(self):
self.prepare()
session = self.get_session(user='******', password='******')
session.execute(
"CREATE USER '*****@*****.**' WITH PASSWORD '12345' NOSUPERUSER"
)
assert_invalid(
session,
"CREATE USER '*****@*****.**' WITH PASSWORD '12345' NOSUPERUSER",
'[email protected] already exists')
def logged_batch_rejects_counter_mutations_test(self):
""" Test that logged batch rejects counter mutations """
session = self.prepare()
err = "Cannot include a counter statement in a logged batch"
assert_invalid(session, """
BEGIN BATCH
INSERT INTO users (id, firstname, lastname) VALUES (0, 'Jack', 'Sparrow')
INSERT INTO users (id, firstname, lastname) VALUES (1, 'Will', 'Turner')
UPDATE clicks SET total = total + 1 WHERE userid = 1 and url = 'http://foo.com'
APPLY BATCH
""", matching=err)
def unlogged_batch_rejects_counter_mutations_test(self):
""" Test that unlogged batch rejects counter mutations """
session = self.prepare()
err = "Counter and non-counter mutations cannot exist in the same batch"
assert_invalid(session, """
BEGIN UNLOGGED BATCH
INSERT INTO users (id, firstname, lastname) VALUES (0, 'Jack', 'Sparrow')
INSERT INTO users (id, firstname, lastname) VALUES (2, 'Elizabeth', 'Swann')
UPDATE clicks SET total = total + 1 WHERE userid = 1 AND url = 'http://foo.com'
APPLY BATCH
""", matching=err)
def test_nested_type_dropping(self):
"""
Confirm a user type can't be dropped when being used by another user type.
"""
cluster = self.cluster
cluster.populate(3).start()
node1, node2, node3 = cluster.nodelist()
cursor = self.patient_cql_connection(node1)
self.create_ks(cursor, 'nested_user_type_dropping', 2)
stmt = """
USE nested_user_type_dropping
"""
cursor.execute(stmt)
stmt = """
CREATE TYPE simple_type (
user_number int,
user_text text
)
"""
cursor.execute(stmt)
stmt = """
CREATE TYPE another_type (
somefield frozen<simple_type>
)
"""
cursor.execute(stmt)
stmt = """
DROP TYPE simple_type;
"""
assert_invalid(cursor, stmt, 'Cannot drop user type nested_user_type_dropping.simple_type as it is still used by user type another_type')
# drop the type that's impeding the drop, and then try again
stmt = """
DROP TYPE another_type;
"""
cursor.execute(stmt)
stmt = """
DROP TYPE simple_type;
"""
cursor.execute(stmt)
# now let's have a look at the system schema and make sure no user types are defined
stmt = """
SELECT type_name from system.schema_usertypes;
"""
rows = cursor.execute(stmt)
self.assertEqual(0, len(rows))
def test_nested_type_dropping(self):
"""
Confirm a user type can't be dropped when being used by another user type.
"""
cluster = self.cluster
cluster.populate(3).start()
node1, node2, node3 = cluster.nodelist()
session = self.patient_cql_connection(node1)
self.create_ks(session, 'nested_user_type_dropping', 2)
session.default_consistency_level = ConsistencyLevel.LOCAL_QUORUM
stmt = """
USE nested_user_type_dropping
"""
session.execute(stmt)
stmt = """
CREATE TYPE simple_type (
user_number int,
user_text text
)
"""
session.execute(stmt)
stmt = """
CREATE TYPE another_type (
somefield frozen<simple_type>
)
"""
session.execute(stmt)
stmt = """
DROP TYPE simple_type;
"""
assert_invalid(
session, stmt,
'Cannot drop user type nested_user_type_dropping.simple_type as it is still used by user type another_type'
)
# drop the type that's impeding the drop, and then try again
stmt = """
DROP TYPE another_type;
"""
session.execute(stmt)
stmt = """
DROP TYPE simple_type;
"""
session.execute(stmt)
# now let's have a look at the system schema and make sure no user types are defined
self.assertNoTypes(session)
def prepared_statement_invalidation_test(self):
"""
@jira_ticket CASSANDRA-7910
- CREATE a table and INSERT a row
- prepare 2 prepared SELECT statements
- SELECT the row with a bound prepared statement and assert it returns the expected row
- ALTER the table, dropping a column
- assert prepared statement without that column in it still works
- assert prepared statement containing that column fails
- ALTER the table, adding a column
- assert prepared statement without that column in it still works
- assert prepared statement containing that column also still works
- ALTER the table, changing the type of a column
- assert that both prepared statements still work
# TODO this basically tests driver behavior if I read it correctly.
# Should this be in dtests at all?
# TODO should these assert that the ALTERs happened correctly?
"""
session = self.prepare()
session.execute("CREATE TABLE test (k int PRIMARY KEY, a int, b int, c int)")
session.execute("INSERT INTO test (k, a, b, c) VALUES (0, 0, 0, 0)")
wildcard_prepared = session.prepare("SELECT * FROM test")
explicit_prepared = session.prepare("SELECT k, a, b, c FROM test")
result = session.execute(wildcard_prepared.bind(None))
self.assertEqual(result, [(0, 0, 0, 0)])
session.execute("ALTER TABLE test DROP c")
result = session.execute(wildcard_prepared.bind(None))
# wildcard select can be automatically re-prepared by the driver
self.assertEqual(result, [(0, 0, 0)])
# but re-preparing the statement with explicit columns should fail
# (see PYTHON-207 for why we expect InvalidRequestException instead of the normal exc)
assert_invalid(session, explicit_prepared.bind(None), expected=InvalidRequest)
session.execute("ALTER TABLE test ADD d int")
result = session.execute(wildcard_prepared.bind(None))
self.assertEqual(result, [(0, 0, 0, None)])
explicit_prepared = session.prepare("SELECT k, a, b, d FROM test")
# when the type is altered, both statements will need to be re-prepared
# by the driver, but the re-preparation should succeed
session.execute("ALTER TABLE test ALTER d TYPE blob")
result = session.execute(wildcard_prepared.bind(None))
self.assertEqual(result, [(0, 0, 0, None)])
result = session.execute(explicit_prepared.bind(None))
self.assertEqual(result, [(0, 0, 0, None)])
def counter_batch_rejects_regular_mutations_test(self):
""" Test that counter batch rejects non-counter mutations """
session = self.prepare()
err = "Cannot include non-counter statement in a counter batch"
assert_invalid(session, """
BEGIN COUNTER BATCH
UPDATE clicks SET total = total + 1 WHERE userid = 1 and url = 'http://foo.com'
UPDATE clicks SET total = total + 1 WHERE userid = 1 and url = 'http://bar.com'
UPDATE clicks SET total = total + 1 WHERE userid = 2 and url = 'http://baz.com'
INSERT INTO users (id, firstname, lastname) VALUES (0, 'Jack', 'Sparrow')
APPLY BATCH
""", matching=err)
def unlogged_batch_rejects_counter_mutations_test(self):
""" Test that unlogged batch rejects counter mutations """
cursor = self.prepare()
assert_invalid(
cursor,
"""
BEGIN UNLOGGED BATCH
INSERT INTO users (id, firstname, lastname) VALUES (0, 'Jack', 'Sparrow')
INSERT INTO users (id, firstname, lastname) VALUES (2, 'Elizabeth', 'Swann')
UPDATE clicks SET total = total + 1 WHERE userid = 1 AND url = 'http://foo.com'
APPLY BATCH
""",
matching="Counter mutations are only allowed in COUNTER batches")
def prepared_statement_invalidation_test(self):
"""
@jira_ticket CASSANDRA-7910
- CREATE a table and INSERT a row
- prepare 2 prepared SELECT statements
- SELECT the row with a bound prepared statement and assert it returns the expected row
- ALTER the table, dropping a column
- assert prepared statement without that column in it still works
- assert prepared statement containing that column fails
- ALTER the table, adding a column
- assert prepared statement without that column in it still works
- assert prepared statement containing that column also still works
- ALTER the table, changing the type of a column
- assert that both prepared statements still work
"""
session = self.prepare()
session.execute(
"CREATE TABLE test (k int PRIMARY KEY, a int, b int, c int)")
session.execute("INSERT INTO test (k, a, b, c) VALUES (0, 0, 0, 0)")
wildcard_prepared = session.prepare("SELECT * FROM test")
explicit_prepared = session.prepare("SELECT k, a, b, c FROM test")
result = session.execute(wildcard_prepared.bind(None))
self.assertEqual(result, [(0, 0, 0, 0)])
session.execute("ALTER TABLE test DROP c")
result = session.execute(wildcard_prepared.bind(None))
# wildcard select can be automatically re-prepared by the driver
self.assertEqual(result, [(0, 0, 0)])
# but re-preparing the statement with explicit columns should fail
# (see PYTHON-207 for why we expect InvalidRequestException instead of the normal exc)
assert_invalid(session,
explicit_prepared.bind(None),
expected=InvalidRequest)
session.execute("ALTER TABLE test ADD d int")
result = session.execute(wildcard_prepared.bind(None))
self.assertEqual(result, [(0, 0, 0, None)])
explicit_prepared = session.prepare("SELECT k, a, b, d FROM test")
# when the type is altered, both statements will need to be re-prepared
# by the driver, but the re-preparation should succeed
session.execute("ALTER TABLE test ALTER d TYPE blob")
result = session.execute(wildcard_prepared.bind(None))
self.assertEqual(result, [(0, 0, 0, None)])
result = session.execute(explicit_prepared.bind(None))
self.assertEqual(result, [(0, 0, 0, None)])
def test_multiple_indexes_on_single_map_column(self):
"""
verifying functionality of multiple unique secondary indexes on a single column
@jira_ticket CASSANDRA-7771
@since 3.0
"""
cluster = self.cluster
cluster.populate(1).start()
[node1] = cluster.nodelist()
session = self.patient_cql_connection(node1)
self.create_ks(session, 'map_double_index', 1)
session.execute("""
CREATE TABLE map_tbl (
id uuid primary key,
amap map<text, int>
)
""")
session.execute("CREATE INDEX map_keys ON map_tbl(keys(amap))")
session.execute("CREATE INDEX map_values ON map_tbl(amap)")
session.execute("CREATE INDEX map_entries ON map_tbl(entries(amap))")
# multiple indexes on a single column are allowed but identical duplicate indexes are not
assert_invalid(session,
"CREATE INDEX map_values_2 ON map_tbl(amap)",
'Index map_values_2 is a duplicate of existing index map_values')
session.execute("INSERT INTO map_tbl (id, amap) values (uuid(), {'foo': 1, 'bar': 2});")
session.execute("INSERT INTO map_tbl (id, amap) values (uuid(), {'faz': 1, 'baz': 2});")
value_search = list(session.execute("SELECT * FROM map_tbl WHERE amap CONTAINS 1"))
self.assertEqual(2, len(value_search), "incorrect number of rows when querying on map values")
key_search = list(session.execute("SELECT * FROM map_tbl WHERE amap CONTAINS KEY 'foo'"))
self.assertEqual(1, len(key_search), "incorrect number of rows when querying on map keys")
entries_search = list(session.execute("SELECT * FROM map_tbl WHERE amap['foo'] = 1"))
self.assertEqual(1, len(entries_search), "incorrect number of rows when querying on map entries")
session.cluster.refresh_schema_metadata()
table_meta = session.cluster.metadata.keyspaces["map_double_index"].tables["map_tbl"]
self.assertEqual(3, len(table_meta.indexes))
self.assertItemsEqual(['map_keys', 'map_values', 'map_entries'], table_meta.indexes)
self.assertEqual(3, len(session.cluster.metadata.keyspaces["map_double_index"].indexes))
self.assertTrue('map_keys' in table_meta.export_as_string())
self.assertTrue('map_values' in table_meta.export_as_string())
self.assertTrue('map_entries' in table_meta.export_as_string())
session.execute("DROP TABLE map_tbl")
session.cluster.refresh_schema_metadata()
self.assertEqual(0, len(session.cluster.metadata.keyspaces["map_double_index"].indexes))
def aggregate_with_udt_keyspace_isolation_test(self):
"""
Ensure aggregates dont allow a UDT from another keyspace
@jira_ticket CASSANDRA-9409
"""
session = self.prepare()
session.execute("create type udt (a int);")
self.create_ks(session, 'user_ks', 1)
assert_invalid(
session,
"create aggregate suma (ks.udt) sfunc plus stype int finalfunc stri initcond 10",
"Statement on keyspace user_ks cannot refer to a user type in keyspace ks"
)
def drop_column_test(self):
"""Test that we cannot drop a column if it is used by a MV"""
session = self.prepare(user_table=True)
result = session.execute(("SELECT * FROM system_schema.materialized_views "
"WHERE keyspace_name='ks' AND table_name='users'"))
self.assertEqual(len(result), 1, "Expecting {} materialized view, got {}".format(1, len(result)))
assert_invalid(
session,
"ALTER TABLE ks.users DROP state;",
"Cannot drop column state, depended on by materialized views"
)
def test_type_enforcement(self):
"""
Confirm error when incorrect data type used for user type
"""
cluster = self.cluster
cluster.populate(3).start()
node1, node2, node3 = cluster.nodelist()
session = self.cql_connection(node1)
self.create_ks(session, 'user_type_enforcement', 2)
session.default_consistency_level = ConsistencyLevel.LOCAL_QUORUM
stmt = """
USE user_type_enforcement
"""
session.execute(stmt)
stmt = """
CREATE TYPE simple_type (
user_number int
)
"""
session.execute(stmt)
stmt = """
CREATE TABLE simple_table (
id uuid PRIMARY KEY,
number frozen<simple_type>
)
"""
session.execute(stmt)
# Make sure the schema propagate
time.sleep(2)
# here we will attempt an insert statement which should fail
# because the user type is an int, but the insert statement is
# providing text
_id = uuid.uuid4()
stmt = """
INSERT INTO simple_table (id, number)
VALUES ({id}, {{user_number: 'uh oh....this is not a number'}});
""".format(id=_id)
assert_invalid(session, stmt, 'field user_number is not of type int')
# let's check the rowcount and make sure the data
# didn't get inserted when the exception asserted above was thrown
stmt = """
SELECT * FROM simple_table;
"""
rows = list(session.execute(stmt))
self.assertEqual(0, len(rows))
def test_type_enforcement(self):
"""
Confirm error when incorrect data type used for user type
"""
cluster = self.cluster
cluster.populate(3).start()
node1, node2, node3 = cluster.nodelist()
session = self.cql_connection(node1)
self.create_ks(session, 'user_type_enforcement', 2)
session.default_consistency_level = ConsistencyLevel.LOCAL_QUORUM
stmt = """
USE user_type_enforcement
"""
session.execute(stmt)
stmt = """
CREATE TYPE simple_type (
user_number int
)
"""
session.execute(stmt)
stmt = """
CREATE TABLE simple_table (
id uuid PRIMARY KEY,
number frozen<simple_type>
)
"""
session.execute(stmt)
# Make sure the schema propagate
time.sleep(2)
# here we will attempt an insert statement which should fail
# because the user type is an int, but the insert statement is
# providing text
_id = uuid.uuid4()
stmt = """
INSERT INTO simple_table (id, number)
VALUES ({id}, {{user_number: 'uh oh....this is not a number'}});
""".format(id=_id)
assert_invalid(session, stmt, 'field user_number is not of type int')
# let's check the rowcount and make sure the data
# didn't get inserted when the exception asserted above was thrown
stmt = """
SELECT * FROM simple_table;
"""
rows = list(session.execute(stmt))
self.assertEqual(0, len(rows))
def counter_batch_rejects_regular_mutations_test(self):
""" Test that counter batch rejects non-counter mutations """
cursor = self.prepare()
assert_invalid(
cursor,
"""
BEGIN COUNTER BATCH
UPDATE clicks SET total = total + 1 WHERE userid = 1 and url = 'http://foo.com'
UPDATE clicks SET total = total + 1 WHERE userid = 1 and url = 'http://bar.com'
UPDATE clicks SET total = total + 1 WHERE userid = 2 and url = 'http://baz.com'
INSERT INTO users (id, firstname, lastname) VALUES (0, 'Jack', 'Sparrow')
APPLY BATCH
""",
matching="Only counter mutations are allowed in COUNTER batches")
def aggregate_with_udt_keyspace_isolation_test(self):
"""
Ensure aggregates dont allow a UDT from another keyspace
@jira_ticket CASSANDRA-9409
"""
session = self.prepare()
session.execute("create type udt (a int);")
self.create_ks(session, 'user_ks', 1)
assert_invalid(
session,
"create aggregate suma (ks.udt) sfunc plus stype int finalfunc stri initcond 10",
"Statement on keyspace user_ks cannot refer to a user type in keyspace ks"
)
def keyspace_test(self):
"""
CREATE KEYSPACE, USE KEYSPACE, ALTER KEYSPACE, DROP KEYSPACE statements
"""
session = self.prepare(create_keyspace=False)
session.execute("CREATE KEYSPACE ks WITH replication = { 'class':'SimpleStrategy', 'replication_factor':1} AND DURABLE_WRITES = true")
session.execute("USE ks")
session.execute("ALTER KEYSPACE ks WITH replication = { 'class' : 'NetworkTopologyStrategy', 'dc1' : 1 } AND DURABLE_WRITES = false")
session.execute("DROP KEYSPACE ks")
assert_invalid(session, "USE ks", expected=InvalidRequest)
def keyspace_test(self):
"""
CREATE KEYSPACE, USE KEYSPACE, ALTER KEYSPACE, DROP KEYSPACE statements
"""
session = self.prepare(create_keyspace=False)
session.execute("CREATE KEYSPACE ks WITH replication = { 'class':'SimpleStrategy', 'replication_factor':1} AND DURABLE_WRITES = true")
session.execute("USE ks")
session.execute("ALTER KEYSPACE ks WITH replication = { 'class' : 'NetworkTopologyStrategy', 'dc1' : 1 } AND DURABLE_WRITES = false")
session.execute("DROP KEYSPACE ks")
assert_invalid(session, "USE ks", expected=InvalidRequest)
def test_nested_type_dropping(self):
"""
Confirm a user type can't be dropped when being used by another user type.
"""
cluster = self.cluster
cluster.populate(3).start()
node1, node2, node3 = cluster.nodelist()
session = self.patient_cql_connection(node1)
self.create_ks(session, 'nested_user_type_dropping', 2)
session.default_consistency_level = ConsistencyLevel.LOCAL_QUORUM
stmt = """
USE nested_user_type_dropping
"""
session.execute(stmt)
stmt = """
CREATE TYPE simple_type (
user_number int,
user_text text
)
"""
session.execute(stmt)
stmt = """
CREATE TYPE another_type (
somefield frozen<simple_type>
)
"""
session.execute(stmt)
stmt = """
DROP TYPE simple_type;
"""
assert_invalid(session, stmt, 'Cannot drop user type nested_user_type_dropping.simple_type as it is still used by user type another_type')
# drop the type that's impeding the drop, and then try again
stmt = """
DROP TYPE another_type;
"""
session.execute(stmt)
stmt = """
DROP TYPE simple_type;
"""
session.execute(stmt)
# now let's have a look at the system schema and make sure no user types are defined
self.assertNoTypes(session)
def invalid_string_literals_test(self):
"""
@jira_ticket CASSANDRA-8101
"""
session = self.prepare()
assert_invalid(session, u"insert into invalid_string_literals (k, a) VALUES (0, '\u038E\u0394\u03B4\u03E0')")
# since the protocol requires strings to be valid UTF-8, the error response to this is a ProtocolError
session = self.cql_connection(self.cluster.nodelist()[0], keyspace='ks')
session.execute("create table invalid_string_literals (k int primary key, a ascii, b text)")
try:
session.execute("insert into invalid_string_literals (k, c) VALUES (0, '\xc2\x01')")
self.fail("Expected error")
except ProtocolException as e:
self.assertTrue("Cannot decode string as UTF8" in str(e))
def invalid_string_literals_test(self):
"""
@jira_ticket CASSANDRA-8101
"""
session = self.prepare()
assert_invalid(session, u"insert into invalid_string_literals (k, a) VALUES (0, '\u038E\u0394\u03B4\u03E0')")
# since the protocol requires strings to be valid UTF-8, the error response to this is a ProtocolError
session = self.cql_connection(self.cluster.nodelist()[0], keyspace='ks')
session.execute("create table invalid_string_literals (k int primary key, a ascii, b text)")
try:
session.execute("insert into invalid_string_literals (k, c) VALUES (0, '\xc2\x01')")
self.fail("Expected error")
except ProtocolException as e:
self.assertTrue("Cannot decode string as UTF8" in str(e))
def table_test(self):
"""
Smoke test that basic table operations work:
- create 2 tables, one with and one without COMPACT STORAGE
- ALTER the table without COMPACT STORAGE, adding a column
For each of those tables:
- insert 10 values
- SELECT * and assert the values are there
- TRUNCATE the table
- SELECT * and assert there are no values
- DROP the table
- SELECT * and assert the statement raises an InvalidRequest
# TODO run SELECTs to make sure each statement works
"""
session = self.prepare()
session.execute("CREATE TABLE test1 (k int PRIMARY KEY, v1 int)")
session.execute("CREATE TABLE test2 (k int, c1 int, v1 int, PRIMARY KEY (k, c1)) WITH COMPACT STORAGE")
session.execute("ALTER TABLE test1 ADD v2 int")
for i in range(0, 10):
session.execute("INSERT INTO test1 (k, v1, v2) VALUES ({i}, {i}, {i})".format(i=i))
session.execute("INSERT INTO test2 (k, c1, v1) VALUES ({i}, {i}, {i})".format(i=i))
res = sorted(session.execute("SELECT * FROM test1"))
self.assertEqual(rows_to_list(res), [[i, i, i] for i in range(0, 10)])
res = sorted(session.execute("SELECT * FROM test2"))
self.assertEqual(rows_to_list(res), [[i, i, i] for i in range(0, 10)])
session.execute("TRUNCATE test1")
session.execute("TRUNCATE test2")
res = session.execute("SELECT * FROM test1")
self.assertEqual(rows_to_list(res), [])
res = session.execute("SELECT * FROM test2")
self.assertEqual(rows_to_list(res), [])
session.execute("DROP TABLE test1")
session.execute("DROP TABLE test2")
assert_invalid(session, "SELECT * FROM test1", expected=InvalidRequest)
assert_invalid(session, "SELECT * FROM test2", expected=InvalidRequest)
def type_test(self):
"""
CREATE TYPE, ALTER TYPE, DROP TYPE statements
"""
session = self.prepare()
session.execute("CREATE TYPE address_t (street text, city text, zip_code int)")
session.execute("CREATE TABLE test4 (id int PRIMARY KEY, address frozen<address_t>)")
session.execute("ALTER TYPE address_t ADD phones set<text>")
session.execute("CREATE TABLE test5 (id int PRIMARY KEY, address frozen<address_t>)")
session.execute("DROP TABLE test4")
session.execute("DROP TABLE test5")
session.execute("DROP TYPE address_t")
assert_invalid(session, "CREATE TABLE test6 (id int PRIMARY KEY, address frozen<address_t>)", expected=InvalidRequest)
def index_test(self):
"""
CREATE INDEX, DROP INDEX statements
"""
session = self.prepare()
session.execute("CREATE TABLE test3 (k int PRIMARY KEY, v1 int, v2 int)")
session.execute("CREATE INDEX testidx ON test3 (v1)")
for i in xrange(0, 10):
session.execute("INSERT INTO test3 (k, v1, v2) VALUES (%d, %d, %d)" % (i, i, i))
res = session.execute("SELECT * FROM test3 WHERE v1 = 0")
assert rows_to_list(res) == [[0, 0, 0]], res
session.execute("DROP INDEX testidx")
assert_invalid(session, "SELECT * FROM test3 where v1 = 0", expected=InvalidRequest)
