def drop_column_compaction_test(self):
cursor = self.prepare()
cursor.execute("USE ks")
cursor.execute("CREATE TABLE cf (key int PRIMARY KEY, c1 int, c2 int)")
# insert some data.
cursor.execute("INSERT INTO cf (key, c1, c2) VALUES (0, 1, 2)")
cursor.execute("INSERT INTO cf (key, c1, c2) VALUES (1, 2, 3)")
cursor.execute("INSERT INTO cf (key, c1, c2) VALUES (2, 3, 4)")
# drop and readd c1.
cursor.execute("ALTER TABLE cf DROP c1")
cursor.execute("ALTER TABLE cf ADD c1 int")
# add another row.
cursor.execute("INSERT INTO cf (key, c1, c2) VALUES (3, 4, 5)")
node = self.cluster.nodelist()[0]
node.flush()
node.compact()
# erase info on dropped 'c1' column and restart.
cursor.execute("""UPDATE system.schema_columnfamilies
SET dropped_columns = null
WHERE keyspace_name = 'ks' AND columnfamily_name = 'cf'"""
)
node.stop(gently=False)
node.start()
time.sleep(.5)
# test that c1 values have been compacted away.
cursor = self.patient_cql_connection(node, version='3.0.10')
rows = cursor.execute("SELECT c1 FROM ks.cf")
self.assertEqual([[None], [None], [None], [4]],
sorted(rows_to_list(rows)))
def drop_column_compaction_test(self):
cursor = self.prepare()
cursor.execute("USE ks")
cursor.execute("CREATE TABLE cf (key int PRIMARY KEY, c1 int, c2 int)")
# insert some data.
cursor.execute("INSERT INTO cf (key, c1, c2) VALUES (0, 1, 2)")
cursor.execute("INSERT INTO cf (key, c1, c2) VALUES (1, 2, 3)")
cursor.execute("INSERT INTO cf (key, c1, c2) VALUES (2, 3, 4)")
# drop and readd c1.
cursor.execute("ALTER TABLE cf DROP c1")
cursor.execute("ALTER TABLE cf ADD c1 int")
# add another row.
cursor.execute("INSERT INTO cf (key, c1, c2) VALUES (3, 4, 5)")
node = self.cluster.nodelist()[0]
node.flush()
node.compact()
# erase info on dropped 'c1' column and restart.
cursor.execute("""UPDATE system.schema_columnfamilies
SET dropped_columns = null
WHERE keyspace_name = 'ks' AND columnfamily_name = 'cf'""")
node.stop(gently=False)
node.start()
time.sleep(.5)
# test that c1 values have been compacted away.
cursor = self.patient_cql_connection(node, version='3.0.10')
rows = cursor.execute("SELECT c1 FROM ks.cf")
self.assertEqual([[None], [None], [None], [4]], sorted(rows_to_list(rows)))
def assert_one(cursor, query, expected, cl=ConsistencyLevel.ONE):
simple_query = SimpleStatement(query, consistency_level=cl)
res = cursor.execute(simple_query)
list_res = rows_to_list(res)
assert list_res == [
expected
], "Expected %s from %s, but got %s" % (expected, query, list_res)
def drop_counter_column_test(self):
"""Test for CASSANDRA-7831"""
cluster = self.cluster
cluster.populate(1).start()
node1, = cluster.nodelist()
session = self.patient_cql_connection(node1)
self.create_ks(session, 'counter_tests', 1)
session.execute("CREATE TABLE counter_bug (t int, c counter, primary key(t))")
session.execute("UPDATE counter_bug SET c = c + 1 where t = 1")
row = session.execute("SELECT * from counter_bug")
self.assertEqual(rows_to_list(row)[0], [1, 1])
self.assertEqual(len(row), 1)
session.execute("ALTER TABLE counter_bug drop c")
assert_invalid(session, "ALTER TABLE counter_bug add c counter", "Cannot re-add previously dropped counter column c")
def drop_counter_column_test(self):
"""Test for CASSANDRA-7831"""
cluster = self.cluster
cluster.populate(1).start()
node1, = cluster.nodelist()
session = self.patient_cql_connection(node1)
self.create_ks(session, 'counter_tests', 1)
session.execute(
"CREATE TABLE counter_bug (t int, c counter, primary key(t))")
session.execute("UPDATE counter_bug SET c = c + 1 where t = 1")
row = session.execute("SELECT * from counter_bug")
self.assertEqual(rows_to_list(row)[0], [1, 1])
self.assertEqual(len(row), 1)
session.execute("ALTER TABLE counter_bug drop c")
assert_invalid(session, "ALTER TABLE counter_bug add c counter",
"Cannot re-add previously dropped counter column c")
def drop_column_queries_test(self):
cursor = self.prepare()
cursor.execute("USE ks")
cursor.execute("CREATE TABLE cf (key int PRIMARY KEY, c1 int, c2 int)")
cursor.execute("CREATE INDEX ON cf(c2)")
# insert some data.
cursor.execute("INSERT INTO cf (key, c1, c2) VALUES (0, 1, 2)")
cursor.execute("INSERT INTO cf (key, c1, c2) VALUES (1, 2, 3)")
cursor.execute("INSERT INTO cf (key, c1, c2) VALUES (2, 3, 4)")
# drop and readd c1.
cursor.execute("ALTER TABLE cf DROP c1")
cursor.execute("ALTER TABLE cf ADD c1 int")
# add another row.
cursor.execute("INSERT INTO cf (key, c1, c2) VALUES (3, 4, 5)")
# test that old (pre-drop) c1 values aren't returned and new ones are.
rows = cursor.execute("SELECT c1 FROM cf")
self.assertEqual([[None], [None], [None], [4]],
sorted(rows_to_list(rows)))
rows = cursor.execute("SELECT * FROM cf")
self.assertEqual([[0, None, 2], [1, None, 3], [2, None, 4], [3, 4, 5]],
sorted(rows_to_list(rows)))
rows = cursor.execute("SELECT c1 FROM cf WHERE key = 0")
self.assertEqual([[None]], rows_to_list(rows))
rows = cursor.execute("SELECT c1 FROM cf WHERE key = 3")
self.assertEqual([[4]], rows_to_list(rows))
rows = cursor.execute("SELECT * FROM cf WHERE c2 = 2")
self.assertEqual([[0, None, 2]], rows_to_list(rows))
rows = cursor.execute("SELECT * FROM cf WHERE c2 = 5")
self.assertEqual([[3, 4, 5]], rows_to_list(rows))
def drop_column_queries_test(self):
cursor = self.prepare()
cursor.execute("USE ks")
cursor.execute("CREATE TABLE cf (key int PRIMARY KEY, c1 int, c2 int)")
cursor.execute("CREATE INDEX ON cf(c2)")
# insert some data.
cursor.execute("INSERT INTO cf (key, c1, c2) VALUES (0, 1, 2)")
cursor.execute("INSERT INTO cf (key, c1, c2) VALUES (1, 2, 3)")
cursor.execute("INSERT INTO cf (key, c1, c2) VALUES (2, 3, 4)")
# drop and readd c1.
cursor.execute("ALTER TABLE cf DROP c1")
cursor.execute("ALTER TABLE cf ADD c1 int")
# add another row.
cursor.execute("INSERT INTO cf (key, c1, c2) VALUES (3, 4, 5)")
# test that old (pre-drop) c1 values aren't returned and new ones are.
rows = cursor.execute("SELECT c1 FROM cf")
self.assertEqual([[None], [None], [None], [4]], sorted(rows_to_list(rows)))
rows = cursor.execute("SELECT * FROM cf")
self.assertEqual([[0,None,2], [1,None,3], [2,None,4], [3,4,5]], sorted(rows_to_list(rows)))
rows = cursor.execute("SELECT c1 FROM cf WHERE key = 0")
self.assertEqual([[None]], rows_to_list(rows))
rows = cursor.execute("SELECT c1 FROM cf WHERE key = 3")
self.assertEqual([[4]], rows_to_list(rows))
rows = cursor.execute("SELECT * FROM cf WHERE c2 = 2")
self.assertEqual([[0,None,2]], rows_to_list(rows))
rows = cursor.execute("SELECT * FROM cf WHERE c2 = 5")
self.assertEqual([[3,4,5]], rows_to_list(rows))
def json_tools_test(self):
debug("Starting cluster...")
cluster = self.cluster
cluster.populate(1).start()
debug("Version: " + cluster.version())
debug("Getting CQLSH...")
[node1] = cluster.nodelist()
cursor = self.patient_cql_connection(node1)
debug("Inserting data...")
self.create_ks(cursor, 'Test', 1)
cursor.execute("""
CREATE TABLE users (
user_name varchar PRIMARY KEY,
password varchar,
gender varchar,
state varchar,
birth_year bigint
);
""")
cursor.execute("INSERT INTO Test. users (user_name, password, gender, state, birth_year) VALUES('frodo', 'pass@', 'male', 'CA', 1985);")
cursor.execute("INSERT INTO Test. users (user_name, password, gender, state, birth_year) VALUES('sam', '@pass', 'male', 'NY', 1980);")
res = cursor.execute("SELECT * FROM Test. users")
self.assertItemsEqual(rows_to_list(res),
[ [ u'frodo', 1985, u'male', u'pass@', u'CA' ],
[u'sam', 1980, u'male', u'@pass', u'NY' ] ] )
debug("Flushing and stopping cluster...")
node1.flush()
cluster.stop()
debug("Exporting to JSON file...")
json_path = tempfile.mktemp(suffix='.schema.json')
with open(json_path, 'w') as f:
node1.run_sstable2json(f)
debug("Deleting cluster and creating new...")
cluster.clear()
cluster.start()
debug("Inserting data...")
cursor = self.patient_cql_connection(node1)
self.create_ks(cursor, 'Test', 1)
cursor.execute("""
CREATE TABLE users (
user_name varchar PRIMARY KEY,
password varchar,
gender varchar,
state varchar,
birth_year bigint
);
""")
cursor.execute("INSERT INTO Test. users (user_name, password, gender, state, birth_year) VALUES('gandalf', 'p@$$', 'male', 'WA', 1955);")
node1.flush()
cluster.stop()
debug("Importing JSON file...")
with open(json_path) as f:
node1.run_json2sstable(f, "test", "users")
os.remove(json_path)
debug("Verifying import...")
cluster.start()
[node1] = cluster.nodelist()
cursor = self.patient_cql_connection(node1)
res = cursor.execute("SELECT * FROM Test. users")
debug("data: " + str(res))
self.assertItemsEqual(rows_to_list(res),
[ [ u'frodo', 1985, u'male', u'pass@', u'CA' ],
[u'sam', 1980, u'male', u'@pass', u'NY' ],
[u'gandalf', 1955, u'male', u'p@$$', u'WA'] ] )
def assert_all(cursor, query, expected, cl=ConsistencyLevel.ONE):
simple_query = SimpleStatement(query, consistency_level=cl)
res = cursor.execute(simple_query)
list_res = rows_to_list(res)
assert list_res == expected, "Expected %s from %s, but got %s" % (expected, query, list_res)
def assert_none(cursor, query, cl=ConsistencyLevel.ONE):
simple_query = SimpleStatement(query, consistency_level=cl)
res = cursor.execute(simple_query)
list_res = rows_to_list(res)
assert list_res == [], "Expected nothing from %s, but got %s" % (query, list_res)
def json_tools_test(self):
debug("Starting cluster...")
cluster = self.cluster
cluster.populate(1).start()
debug("Version: " + cluster.version())
debug("Getting CQLSH...")
[node1] = cluster.nodelist()
cursor = self.patient_cql_connection(node1)
debug("Inserting data...")
self.create_ks(cursor, 'Test', 1)
cursor.execute("""
CREATE TABLE users (
user_name varchar PRIMARY KEY,
password varchar,
gender varchar,
state varchar,
birth_year bigint
);
""")
cursor.execute(
"INSERT INTO Test. users (user_name, password, gender, state, birth_year) VALUES('frodo', 'pass@', 'male', 'CA', 1985);"
)
cursor.execute(
"INSERT INTO Test. users (user_name, password, gender, state, birth_year) VALUES('sam', '@pass', 'male', 'NY', 1980);"
)
res = cursor.execute("SELECT * FROM Test. users")
self.assertItemsEqual(rows_to_list(res),
[[u'frodo', 1985, u'male', u'pass@', u'CA'],
[u'sam', 1980, u'male', u'@pass', u'NY']])
debug("Flushing and stopping cluster...")
node1.flush()
cluster.stop()
debug("Exporting to JSON file...")
json_path = tempfile.mktemp(suffix='.schema.json')
with open(json_path, 'w') as f:
node1.run_sstable2json(f)
if self.cluster.version() >= '2.1':
with open(json_path, 'r') as fin:
data = fin.read().splitlines(True)
if data[0][0] == 'W':
with open(json_path, 'w') as fout:
fout.writelines(data[1:])
debug("Deleting cluster and creating new...")
cluster.clear()
cluster.start()
debug("Inserting data...")
cursor = self.patient_cql_connection(node1)
self.create_ks(cursor, 'Test', 1)
cursor.execute("""
CREATE TABLE users (
user_name varchar PRIMARY KEY,
password varchar,
gender varchar,
state varchar,
birth_year bigint
);
""")
cursor.execute(
"INSERT INTO Test. users (user_name, password, gender, state, birth_year) VALUES('gandalf', 'p@$$', 'male', 'WA', 1955);"
)
node1.flush()
cluster.stop()
debug("Importing JSON file...")
with open(json_path) as f:
node1.run_json2sstable(f, "test", "users")
os.remove(json_path)
debug("Verifying import...")
cluster.start()
[node1] = cluster.nodelist()
cursor = self.patient_cql_connection(node1)
res = cursor.execute("SELECT * FROM Test. users")
debug("data: " + str(res))
self.assertItemsEqual(rows_to_list(res),
[[u'frodo', 1985, u'male', u'pass@', u'CA'],
[u'sam', 1980, u'male', u'@pass', u'NY'],
[u'gandalf', 1955, u'male', u'p@$$', u'WA']])