def test_dense_supercolumn(self):
cursor = self.prepare(nodes=2, rf=2, row_factory=dict_factory)
cluster = self.cluster
node = self.cluster.nodelist()[0]
node.nodetool("enablethrift")
host, port = node.network_interfaces['thrift']
client = get_thrift_client(host, port)
client.transport.open()
client.set_keyspace('ks')
_create_dense_super_cf(client, 'dense_super_1')
for i in range(1, 3):
client.insert('k1'.encode(), ColumnParent('dense_super_1', 'key{}'.format(i).encode()), Column(_i64(100), 'value1'.encode(), 0), ConsistencyLevel.ONE)
client.insert('k2'.encode(), ColumnParent('dense_super_1', 'key{}'.format(i).encode()), Column(_i64(200), 'value2'.encode(), 0), ConsistencyLevel.ONE)
_validate_dense_cql(cursor)
_validate_dense_thrift(client)
if self.upgrade_is_version_4_or_greater(): # 4.0 doesn't support compact storage
cursor.execute("ALTER TABLE ks.dense_super_1 DROP COMPACT STORAGE;")
for is_upgraded, cursor in self.do_upgrade(cursor, row_factory=dict_factory, use_thrift=True):
logger.debug("Querying {} node".format("upgraded" if is_upgraded else "old"))
is_version_4_or_greater = node.get_cassandra_version() >= CASSANDRA_4_0
if not is_version_4_or_greater:
client = get_thrift_client(host, port)
_validate_dense_thrift(client)
_validate_dense_cql(cursor, is_version_4_or_greater=is_version_4_or_greater)
def test_dense_supercolumn_with_renames(self):
cursor = self.prepare(row_factory=dict_factory)
cluster = self.cluster
node = self.cluster.nodelist()[0]
node.nodetool("enablethrift")
host, port = node.network_interfaces['thrift']
client = get_thrift_client(host, port)
client.transport.open()
client.set_keyspace('ks')
client.system_add_column_family(_create_dense_super_cf('dense_super_2'))
for i in range(1, 3):
client.insert('k1', ColumnParent('dense_super_2', 'key{}'.format(i)), Column(_i64(100), 'value1', 0), ConsistencyLevel.ONE)
client.insert('k2', ColumnParent('dense_super_2', 'key{}'.format(i)), Column(_i64(200), 'value2', 0), ConsistencyLevel.ONE)
cursor.execute("ALTER TABLE ks.dense_super_2 RENAME key TO renamed_key")
cursor.execute("ALTER TABLE ks.dense_super_2 RENAME column1 TO renamed_column1")
cursor.execute("ALTER TABLE ks.dense_super_2 RENAME column2 TO renamed_column2")
cursor.execute("ALTER TABLE ks.dense_super_2 RENAME value TO renamed_value")
_validate_dense_cql(cursor, cf='dense_super_2', key='renamed_key', column1='renamed_column1', column2='renamed_column2', value='renamed_value')
_validate_dense_thrift(client, cf='dense_super_2')
for is_upgraded, cursor in self.do_upgrade(cursor, row_factory=dict_factory, use_thrift=True):
logger.debug("Querying {} node".format("upgraded" if is_upgraded else "old"))
client = get_thrift_client(host, port)
_validate_dense_cql(cursor, cf='dense_super_2', key='renamed_key', column1='renamed_column1', column2='renamed_column2', value='renamed_value')
_validate_dense_thrift(client, cf='dense_super_2')
def test_dense_supercolumn(self):
cursor = self.prepare(nodes=2, rf=2, row_factory=dict_factory)
cluster = self.cluster
node = self.cluster.nodelist()[0]
node.nodetool("enablethrift")
host, port = node.network_interfaces['thrift']
client = get_thrift_client(host, port)
client.transport.open()
client.set_keyspace('ks')
client.system_add_column_family(_create_dense_super_cf('dense_super_1'))
for i in range(1, 3):
client.insert('k1', ColumnParent('dense_super_1', 'key{}'.format(i)), Column(_i64(100), 'value1', 0), ConsistencyLevel.ONE)
client.insert('k2', ColumnParent('dense_super_1', 'key{}'.format(i)), Column(_i64(200), 'value2', 0), ConsistencyLevel.ONE)
_validate_dense_cql(cursor)
_validate_dense_thrift(client)
for is_upgraded, cursor in self.do_upgrade(cursor, row_factory=dict_factory, use_thrift=True):
logger.debug("Querying {} node".format("upgraded" if is_upgraded else "old"))
client = get_thrift_client(host, port)
_validate_dense_cql(cursor)
_validate_dense_thrift(client)
def test_dense_supercolumn_3_0_created(self):
cluster = self.prepare(cassandra_version='github:apache/cassandra-3.0')
node = self.cluster.nodelist()[0]
cursor = self.patient_cql_connection(node, row_factory=dict_factory)
cursor.execute("CREATE KEYSPACE ks WITH replication = {'class': 'SimpleStrategy','replication_factor': '1' };")
host, port = node.network_interfaces['thrift']
client = get_thrift_client(host, port)
client.transport.open()
client.set_keyspace('ks')
client.system_add_column_family(_create_dense_super_cf('dense_super_1'))
for i in range(1, 3):
client.insert('k1', ColumnParent('dense_super_1', 'key{}'.format(i)), Column(_i64(100), 'value1', 0), ConsistencyLevel.ONE)
client.insert('k2', ColumnParent('dense_super_1', 'key{}'.format(i)), Column(_i64(200), 'value2', 0), ConsistencyLevel.ONE)
_validate_dense_thrift(client, cf='dense_super_1')
node.stop()
self.set_node_to_current_version(node)
node.set_configuration_options(values={'start_rpc': 'true'})
node.start()
cursor = self.patient_cql_connection(node, row_factory=dict_factory)
client = get_thrift_client(host, port)
_validate_dense_thrift(client, cf='dense_super_1')
_validate_dense_cql(cursor, cf='dense_super_1')
def test_dense_supercolumn(self):
cluster = self.prepare()
node = self.cluster.nodelist()[0]
node.nodetool("enablethrift")
cursor = self.patient_cql_connection(node, row_factory=dict_factory)
cursor.execute(
"CREATE KEYSPACE ks WITH replication = {'class': 'SimpleStrategy','replication_factor': '1' };"
)
host, port = node.network_interfaces['thrift']
client = get_thrift_client(host, port)
client.transport.open()
client.set_keyspace('ks')
_create_dense_super_cf(client, 'dense_super_1')
for i in range(1, 3):
client.insert(
'k1'.encode(),
ColumnParent('dense_super_1', 'key{}'.format(i).encode()),
Column(_i64(100), 'value1'.encode(), 0), ConsistencyLevel.ONE)
client.insert(
'k2'.encode(),
ColumnParent('dense_super_1', 'key{}'.format(i).encode()),
Column(_i64(200), 'value2'.encode(), 0), ConsistencyLevel.ONE)
_validate_dense_thrift(client, cf='dense_super_1')
_validate_dense_cql(cursor, cf='dense_super_1')
self.upgrade_to_version('github:apache/cassandra-3.0')
cursor = self.patient_cql_connection(node, row_factory=dict_factory)
client = get_thrift_client(host, port)
_validate_dense_thrift(client, cf='dense_super_1')
self.set_node_to_current_version(node)
#4.0 doesn't support compact storage
if node.get_cassandra_version() >= '4':
cursor.execute(
"ALTER TABLE ks.dense_super_1 DROP COMPACT STORAGE;")
node.stop()
if node.get_cassandra_version() < '4':
node.set_configuration_options(values={'start_rpc': 'true'})
node.start()
if node.get_cassandra_version() < '4':
client = get_thrift_client(host, port)
_validate_dense_thrift(client, cf='dense_super_1')
cursor = self.patient_cql_connection(node, row_factory=dict_factory)
_validate_dense_cql(
cursor,
cf='dense_super_1',
is_version_4_or_greater=node.get_cassandra_version() >=
CASSANDRA_4_0)
def _validate_dense_thrift(client, cf='dense_super_1'):
client.transport.open()
client.set_keyspace('ks')
result = client.get_slice('k1', ColumnParent(cf), SlicePredicate(slice_range=SliceRange('', '', False, 5)), ConsistencyLevel.ONE)
assert_length_equal(result, 2)
assert result[0].super_column.name == 'key1'
assert result[1].super_column.name == 'key2'
print((result[0]))
print((result[1]))
for cosc in result:
assert cosc.super_column.columns[0].name == _i64(100)
assert cosc.super_column.columns[0].value == 'value1'
def test_dense_supercolumn_with_renames(self):
cursor = self.prepare(row_factory=dict_factory)
cluster = self.cluster
node = self.cluster.nodelist()[0]
node.nodetool("enablethrift")
host, port = node.network_interfaces['thrift']
client = get_thrift_client(host, port)
client.transport.open()
client.set_keyspace('ks')
_create_dense_super_cf(client, 'dense_super_2')
for i in range(1, 3):
client.insert('k1'.encode(), ColumnParent('dense_super_2', 'key{}'.format(i).encode()), Column(_i64(100), 'value1'.encode(), 0), ConsistencyLevel.ONE)
client.insert('k2'.encode(), ColumnParent('dense_super_2', 'key{}'.format(i).encode()), Column(_i64(200), 'value2'.encode(), 0), ConsistencyLevel.ONE)
cursor.execute("ALTER TABLE ks.dense_super_2 RENAME key TO renamed_key")
cursor.execute("ALTER TABLE ks.dense_super_2 RENAME column1 TO renamed_column1")
cursor.execute("ALTER TABLE ks.dense_super_2 RENAME column2 TO renamed_column2")
cursor.execute("ALTER TABLE ks.dense_super_2 RENAME value TO renamed_value")
_validate_dense_cql(cursor, cf='dense_super_2', key='renamed_key', column1='renamed_column1', column2='renamed_column2', value='renamed_value')
_validate_dense_thrift(client, cf='dense_super_2')
version_string = self.upgrade_version_string()
is_version_4_or_greater = version_string == 'trunk' or version_string >= '4.0'
#4.0 doesn't support compact storage
if is_version_4_or_greater:
cursor.execute("ALTER TABLE ks.dense_super_2 DROP COMPACT STORAGE;")
for is_upgraded, cursor in self.do_upgrade(cursor, row_factory=dict_factory, use_thrift=True):
logger.debug("Querying {} node".format("upgraded" if is_upgraded else "old"))
if not is_version_4_or_greater:
client = get_thrift_client(host, port)
_validate_dense_thrift(client, cf='dense_super_2')
_validate_dense_cql(cursor, cf='dense_super_2', key='renamed_key', column1='renamed_column1', column2='renamed_column2', value='renamed_value', is_version_4_or_greater=is_version_4_or_greater)
def verify_with_thrift(self):
# No more thrift in 4.0
if self.cluster.version() >= '4':
return
node = self.cluster.nodelist()[0]
host, port = node.network_interfaces['thrift']
client = get_thrift_client(host, port)
client.transport.open()
client.set_keyspace('supcols')
p = SlicePredicate(slice_range=SliceRange('', '', False, 1000))
for name in NAMES:
super_col_value = client.get_slice(name, ColumnParent("cols"), p,
ConsistencyLevel.ONE)
logger.debug("get_slice(%s) returned %s" % (name, super_col_value))
assert name == super_col_value[0].column.value
def _validate_sparse_thrift(client, cf='sparse_super_1'):
try:
client.transport.open()
except:
pass
client.set_keyspace('ks')
result = client.get_slice('k1'.encode(), ColumnParent(cf), SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 5)), ConsistencyLevel.ONE)
assert_length_equal(result, 2)
assert result[0].super_column.name == 'key1'.encode()
assert result[1].super_column.name == 'key2'.encode()
for cosc in result:
assert cosc.super_column.columns[0].name == 'col1'.encode()
assert cosc.super_column.columns[0].value == _i64(200)
assert cosc.super_column.columns[1].name == 'col2'.encode()
assert cosc.super_column.columns[1].value == _i64(300)
assert cosc.super_column.columns[2].name == 'value1'.encode()
assert cosc.super_column.columns[2].value == _i64(100)
def test_functional(self):
NUM_SUBCOLS = 100
NUM_ADDS = 100
cluster = self.cluster
cluster.populate(3).start()
node1 = cluster.nodelist()[0]
time.sleep(.5)
session = self.patient_cql_connection(node1)
create_ks(session, 'ks', 3)
time.sleep(1) # wait for propagation
# create the columnfamily using thrift
host, port = node1.network_interfaces['thrift']
thrift_conn = get_thrift_client(host, port)
thrift_conn.transport.open()
thrift_conn.set_keyspace('ks')
cf_def = CfDef(keyspace='ks',
name='cf',
column_type='Super',
default_validation_class='CounterColumnType')
thrift_conn.system_add_column_family(cf_def)
# let the sediment settle to to the bottom before drinking...
time.sleep(2)
for subcol in range(NUM_SUBCOLS):
for add in range(NUM_ADDS):
column_parent = ColumnParent(column_family='cf',
super_column=('subcol_%d' %
subcol).encode())
counter_column = CounterColumn('col_0'.encode(), 1)
thrift_conn.add('row_0'.encode(), column_parent,
counter_column, ConsistencyLevel.QUORUM)
time.sleep(1)
cluster.flush()
logger.debug("Stopping cluster")
cluster.stop()
time.sleep(5)
logger.debug("Starting cluster")
cluster.start()
time.sleep(5)
thrift_conn = get_thrift_client(host, port)
thrift_conn.transport.open()
thrift_conn.set_keyspace('ks')
from_db = []
for i in range(NUM_SUBCOLS):
column_path = ColumnPath(column_family='cf',
column='col_0'.encode(),
super_column=(('subcol_%d' % i).encode()))
column_or_super_column = thrift_conn.get('row_0'.encode(),
column_path,
ConsistencyLevel.QUORUM)
val = column_or_super_column.counter_column.value
logger.debug(str(val)),
from_db.append(val)
logger.debug("")
expected = [NUM_ADDS for i in range(NUM_SUBCOLS)]
if from_db != expected:
raise Exception(
"Expected a bunch of the same values out of the db. Got this: "
+ str(from_db))
def test_sparse_supercolumn_with_renames(self):
cursor = self.prepare(row_factory=dict_factory)
cluster = self.cluster
node = self.cluster.nodelist()[0]
node.nodetool("enablethrift")
host, port = node.network_interfaces['thrift']
client = get_thrift_client(host, port)
client.transport.open()
client.set_keyspace('ks')
_create_sparse_super_cf(client, 'sparse_super_1')
cursor.execute(
"ALTER TABLE ks.sparse_super_1 RENAME key TO renamed_key")
cursor.execute(
"ALTER TABLE ks.sparse_super_1 RENAME column1 TO renamed_column1")
for i in range(1, 3):
client.insert(
'k1'.encode(),
ColumnParent('sparse_super_1', 'key{}'.format(i).encode()),
Column("value1".encode(), _i64(100), 0), ConsistencyLevel.ONE)
client.insert(
'k1'.encode(),
ColumnParent('sparse_super_1', 'key{}'.format(i).encode()),
Column("col1".encode(), _i64(200), 0), ConsistencyLevel.ONE)
client.insert(
'k1'.encode(),
ColumnParent('sparse_super_1', 'key{}'.format(i).encode()),
Column("col2".encode(), _i64(300), 0), ConsistencyLevel.ONE)
client.insert(
'k2'.encode(),
ColumnParent('sparse_super_1', 'key{}'.format(i).encode()),
Column("value2".encode(), _i64(100), 0), ConsistencyLevel.ONE)
client.insert(
'k2'.encode(),
ColumnParent('sparse_super_1', 'key{}'.format(i).encode()),
Column("col1".encode(), _i64(200), 0), ConsistencyLevel.ONE)
client.insert(
'k2'.encode(),
ColumnParent('sparse_super_1', 'key{}'.format(i).encode()),
Column("col2".encode(), _i64(300), 0), ConsistencyLevel.ONE)
_validate_sparse_thrift(client)
_validate_sparse_cql(cursor,
column1='renamed_column1',
key='renamed_key')
if self.upgrade_is_version_4_or_greater(
): # 4.0 doesn't support compact storage
cursor.execute(
"ALTER TABLE ks.sparse_super_1 DROP COMPACT STORAGE;")
for is_upgraded, cursor in self.do_upgrade(cursor,
row_factory=dict_factory,
use_thrift=True):
logger.debug("Querying {} node".format(
"upgraded" if is_upgraded else "old"))
if not is_version_4_or_greater:
client = get_thrift_client(host, port)
_validate_sparse_thrift(client)
_validate_sparse_cql(
cursor,
column1='renamed_column1',
key='renamed_key',
is_version_4_or_greater=is_version_4_or_greater)
