schema_metadata_test.py

import pytest
import logging

from collections import defaultdict
from uuid import uuid4

from dtest import Tester, create_ks

since = pytest.mark.since
logger = logging.getLogger(__name__)


def establish_durable_writes_keyspace(version, session, table_name_prefix=""):
    session.execute("""
        CREATE KEYSPACE {}
            WITH replication = {{'class': 'SimpleStrategy', 'replication_factor': 1}};
    """.format(_cql_name_builder(table_name_prefix, "durable_writes_default")))

    session.execute("""
        CREATE KEYSPACE {}
            WITH replication = {{'class': 'SimpleStrategy', 'replication_factor': 1}}
            AND durable_writes = 'false';
    """.format(_cql_name_builder(table_name_prefix, "durable_writes_false")))

    session.execute("""
        CREATE KEYSPACE {}
            WITH replication = {{'class': 'SimpleStrategy', 'replication_factor': 1}}
            AND durable_writes = 'true';
    """.format(_cql_name_builder(table_name_prefix, "durable_writes_true")))


def verify_durable_writes_keyspace(created_on_version, current_version, keyspace, session, table_name_prefix=""):
    expected = {
        "durable_writes_default": True,
        "durable_writes_true": True,
        "durable_writes_false": False
    }
    for keyspace, is_durable in expected.items():
        keyspace_name = _cql_name_builder(table_name_prefix, keyspace)
        meta = session.cluster.metadata.keyspaces[keyspace_name]
        assert is_durable == meta.durable_writes, "keyspace [{}] had durable_writes of [{}] should be [{}]".format(keyspace_name, meta.durable_writes, is_durable)


def establish_indexes_table(version, session, table_name_prefix=""):
    table_name = _cql_name_builder(table_name_prefix, "test_indexes")
    cql = """
            create table {0} (
                        a uuid,
                        b uuid,
                        c uuid,
                        d uuid,
                        e uuid,
                        primary key((a,b),c))
              """

    session.execute(cql.format(table_name))
    index_name = _cql_name_builder("idx_" + table_name_prefix, table_name)
    logger.debug("table name: [{}], index name: [{}], prefix: [{}]".format(table_name, index_name, table_name_prefix))
    session.execute("CREATE INDEX {0} ON {1}( d )".format(index_name, table_name))


def verify_indexes_table(created_on_version, current_version, keyspace, session, table_name_prefix=""):
    table_name = _cql_name_builder(table_name_prefix, "test_indexes")
    index_name = _cql_name_builder("idx_" + table_name_prefix, table_name)
    logger.debug("table name: [{}], index name: [{}], prefix: [{}]".format(table_name, index_name, table_name_prefix))
    meta = session.cluster.metadata.keyspaces[keyspace].indexes[index_name]

    assert 'd' == meta.index_options['target']

    meta = session.cluster.metadata.keyspaces[keyspace].tables[table_name]
    assert 1 == len(meta.clustering_key)
    assert 'c' == meta.clustering_key[0].name

    assert 1 == len(meta.indexes)

    opts = dict(meta.indexes[index_name].index_options)
    # we do not want the class name (set when SAI is the default index class) to break this
    opts = { k : opts[k] for k in set(opts) - {'class_name'} }

    assert {'target': 'd'} == opts
    assert 3 == len(meta.primary_key)
    assert 'a' == meta.primary_key[0].name
    assert 'b' == meta.primary_key[1].name
    assert 'c' == meta.primary_key[2].name


def establish_clustering_order_table(version, session, table_name_prefix=""):
    table_name = _cql_name_builder(table_name_prefix, "test_clustering_order")
    cql = """
                CREATE TABLE {0} (
                  event_type text,
                  insertion_time timestamp,
                  event blob,
                  PRIMARY KEY (event_type, insertion_time)
                )
                WITH CLUSTERING ORDER BY (insertion_time DESC);
              """

    session.execute(cql.format(table_name))


def verify_clustering_order_table(created_on_version, current_version, keyspace, session, table_name_prefix=""):
    table_name = _cql_name_builder(table_name_prefix, "test_clustering_order")
    meta = session.cluster.metadata.keyspaces[keyspace].tables[table_name]
    assert 0 == len(meta.indexes)
    assert 2 == len(meta.primary_key)
    assert 'event_type' == meta.primary_key[0].name
    assert 'insertion_time' == meta.primary_key[1].name
    assert 1 == len(meta.clustering_key)
    assert 'insertion_time' == meta.clustering_key[0].name
    assert 'insertion_time DESC' in meta.as_cql_query()


def establish_compact_storage_table(version, session, table_name_prefix=""):
    table_name = _cql_name_builder(table_name_prefix, "test_compact_storage")
    cql = """
                CREATE TABLE {0} (
                  block_id uuid,
                  sub_block_id int,
                  stuff blob,
                  PRIMARY KEY (block_id, sub_block_id)
                )
                WITH COMPACT STORAGE;
              """

    session.execute(cql.format(table_name))


def verify_compact_storage_table(created_on_version, current_version, keyspace, session, table_name_prefix=""):
    table_name = _cql_name_builder(table_name_prefix, "test_compact_storage")
    meta = session.cluster.metadata.keyspaces[keyspace].tables[table_name]
    assert 3 == len(meta.columns)
    assert 2 == len(meta.primary_key)
    assert 1 == len(meta.clustering_key)
    assert 'sub_block_id' == meta.clustering_key[0].name
    assert 'block_id' == meta.primary_key[0].name
    assert 'uuid' == meta.primary_key[0].cql_type
    assert 'sub_block_id' == meta.primary_key[1].name
    assert 'int' == meta.primary_key[1].cql_type
    assert 1 == len(meta.clustering_key)
    assert 'sub_block_id' == meta.clustering_key[0].name


def establish_compact_storage_composite_table(version, session, table_name_prefix=""):
    table_name = _cql_name_builder(table_name_prefix, "test_compact_storage_composite")
    cql = """
                CREATE TABLE {0} (
                    key text,
                    column1 int,
                    column2 int,
                    value text,
                    PRIMARY KEY(key, column1, column2)
                ) WITH COMPACT STORAGE;
              """

    session.execute(cql.format(table_name))


def verify_compact_storage_composite_table(created_on_version, current_version, keyspace, session, table_name_prefix=""):
    table_name = _cql_name_builder(table_name_prefix, "test_compact_storage_composite")
    meta = session.cluster.metadata.keyspaces[keyspace].tables[table_name]
    assert 4 == len(meta.columns)
    assert 3 == len(meta.primary_key)
    assert 'key' == meta.primary_key[0].name
    assert 'text' == meta.primary_key[0].cql_type
    assert 'column1' == meta.primary_key[1].name
    assert 'int' == meta.primary_key[1].cql_type
    assert 'column2' == meta.primary_key[2].name
    assert 'int' == meta.primary_key[2].cql_type
    assert 2 == len(meta.clustering_key)
    assert 'column1' == meta.clustering_key[0].name
    assert 'int' == meta.clustering_key[0].cql_type
    assert 'column2' == meta.clustering_key[1].name
    assert 'int' == meta.clustering_key[1].cql_type


def establish_nondefault_table_settings(version, session, table_name_prefix=""):
    table_name = _cql_name_builder(table_name_prefix, "test_nondefault_settings")
    cql = """
        create table {0} (
                    a uuid,
                    b uuid,
                    c uuid,
                    d uuid,
                    primary key((a,b),c) )
                WITH gc_grace_seconds = 9999
                AND bloom_filter_fp_chance = 0.5
                AND comment = 'insightful information'
                AND compaction = {{'class': 'LeveledCompactionStrategy'}}
          """

    if version >= '3.0':
        cql += " AND compression = {{'class': 'DeflateCompressor', 'chunk_length_in_kb' : 128}}"
    else:
        cql += " AND compression = {{'sstable_compression': 'DeflateCompressor', 'chunk_length_kb' : 128}}"

    if version >= '3.0':
        cql += """ AND memtable_flush_period_in_ms = 2121
                   AND speculative_retry = '55PERCENTILE'"""

    if version >= '2.1':
        cql += """ AND max_index_interval = 20
                   AND min_index_interval = 1
                   AND default_time_to_live = 86400
                   AND caching = {{'keys': 'NONE', 'rows_per_partition': 'ALL'}}"""

    if version >= '2.0' and version <= '3.0':
        cql += " AND index_interval = 1"

    if version < '2.1':
        cql += " AND caching = 'ROWS_ONLY'"

    session.execute(cql.format(table_name))


def verify_nondefault_table_settings(created_on_version, current_version, keyspace, session, table_name_prefix=""):
    table_name = _cql_name_builder(table_name_prefix, "test_nondefault_settings")
    meta = session.cluster.metadata.keyspaces[keyspace].tables[table_name]

    assert 'insightful information' == meta.options['comment']
    assert 9999 == meta.options['gc_grace_seconds']
    assert 0.5 == meta.options['bloom_filter_fp_chance']

    if created_on_version >= '2.1':
        assert 86400 == meta.options['default_time_to_live']
        assert 1 == meta.options['min_index_interval']
        assert 20 == meta.options['max_index_interval']

    if created_on_version >= '3.0':
        assert 2121 == meta.options['memtable_flush_period_in_ms']

    if created_on_version >= '3.0':
        if created_on_version >= '4.0':
            assert '55p' == meta.options['speculative_retry']
        else:
            assert '55PERCENTILE' == meta.options['speculative_retry']

    if current_version >= '3.0':
        assert 'org.apache.cassandra.io.compress.DeflateCompressor' == meta.options['compression']['class']
        assert '128' == meta.options['compression']['chunk_length_in_kb']
        assert 'org.apache.cassandra.db.compaction.LeveledCompactionStrategy' == meta.options['compaction']['class']

    if '2.1' <= current_version < '3.0':
        assert '{"keys":"NONE", "rows_per_partition":"ALL"}' == meta.options['caching']
        assert '"chunk_length_kb":"128"' in meta.options['compression_parameters']
        assert '"sstable_compression":"org.apache.cassandra.io.compress.DeflateCompressor"' in meta.options['compression_parameters']
    elif current_version >= '3.0':
        assert 'NONE' == meta.options['caching']['keys']
        assert 'ALL' == meta.options['caching']['rows_per_partition']
        assert 'org.apache.cassandra.io.compress.DeflateCompressor' == meta.options['compression']['class']
        assert '128' == meta.options['compression']['chunk_length_in_kb']
        assert 'org.apache.cassandra.db.compaction.LeveledCompactionStrategy' == meta.options['compaction']['class']
    else:
        assert 'ROWS_ONLY' == meta.options['caching']

    assert 2 == len(meta.partition_key)
    assert meta.partition_key[0].name == 'a'
    assert meta.partition_key[1].name == 'b'

    assert 1 == len(meta.clustering_key)
    assert meta.clustering_key[0].name == 'c'


def establish_uda(version, session, table_name_prefix=""):
    if version < '2.2':
        return
    function_name = _cql_name_builder(table_name_prefix, "test_uda_function")
    aggregate_name = _cql_name_builder(table_name_prefix, "test_uda_aggregate")

    session.execute('''
            CREATE FUNCTION {0}(current int, candidate int)
            CALLED ON NULL INPUT
            RETURNS int LANGUAGE java AS
            'if (current == null) return candidate; else return Math.max(current, candidate);';
        '''.format(function_name))

    session.execute('''
            CREATE AGGREGATE {0}(int)
            SFUNC {1}
            STYPE int
            INITCOND null;
        '''.format(aggregate_name, function_name))


def verify_uda(created_on_version, current_version, keyspace, session, table_name_prefix=""):
    if created_on_version < '2.2':
        return
    function_name = _cql_name_builder(table_name_prefix, "test_uda_function")
    aggregate_name = _cql_name_builder(table_name_prefix, "test_uda_aggregate")

    assert function_name + "(int,int)" in list(session.cluster.metadata.keyspaces[keyspace].functions.keys())
    assert aggregate_name + "(int)" in list(session.cluster.metadata.keyspaces[keyspace].aggregates.keys())

    aggr_meta = session.cluster.metadata.keyspaces[keyspace].aggregates[aggregate_name + "(int)"]
    assert function_name == aggr_meta.state_func
    assert 'int' == aggr_meta.state_type
    assert 'int' == aggr_meta.return_type


def establish_udf(version, session, table_name_prefix=""):
    if version < '2.2':
        return
    function_name = _cql_name_builder(table_name_prefix, "test_udf")
    session.execute('''
        CREATE OR REPLACE FUNCTION {0} (input double) CALLED ON NULL INPUT RETURNS double LANGUAGE java AS 'return Double.valueOf(Math.log(input.doubleValue()));';
        '''.format(function_name))


def verify_udf(created_on_version, current_version, keyspace, session, table_name_prefix=""):
    if created_on_version < '2.2':
        return
    function_name = _cql_name_builder(table_name_prefix, "test_udf")
    assert function_name + "(double)" in list(session.cluster.metadata.keyspaces[keyspace].functions.keys())
    meta = session.cluster.metadata.keyspaces[keyspace].functions[function_name + "(double)"]
    assert 'java' == meta.language
    assert 'double' == meta.return_type
    assert ['double'] == meta.argument_types
    assert ['input'] == meta.argument_names
    assert 'return Double.valueOf(Math.log(input.doubleValue()));' == meta.body


def establish_udt_table(version, session, table_name_prefix=""):
    if version < '2.1':
        return
    table_name = _cql_name_builder(table_name_prefix, "test_udt")
    session.execute('''
          CREATE TYPE {0} (
              street text,
              city text,
              zip int
          )'''.format(table_name))


def verify_udt_table(created_on_version, current_version, keyspace, session, table_name_prefix=""):
    if created_on_version < '2.1':
        return
    table_name = _cql_name_builder(table_name_prefix, "test_udt")
    meta = session.cluster.metadata.keyspaces[keyspace].user_types[table_name]

    assert meta.field_names == ['street', 'city', 'zip']
    assert 'street' == meta.field_names[0]
    assert 'text' == meta.field_types[0]
    assert 'city' == meta.field_names[1]
    assert 'text' == meta.field_types[1]
    assert 'zip' == meta.field_names[2]
    assert 'int' == meta.field_types[2]


def establish_static_column_table(version, session, table_name_prefix=""):
    if version < '2.0':
        return
    table_name = _cql_name_builder(table_name_prefix, "test_static_column")
    session.execute('''
          CREATE TABLE {0} (
             user text,
             balance int static,
             expense_id int,
             amount int,
             PRIMARY KEY (user, expense_id)
          )'''.format(table_name))


def verify_static_column_table(created_on_version, current_version, keyspace, session, table_name_prefix=""):
    if created_on_version < '2.0':
        return
    table_name = _cql_name_builder(table_name_prefix, "test_static_column")
    meta = session.cluster.metadata.keyspaces[keyspace].tables[table_name]
    assert 4 == len(meta.columns)
    assert 'text' == meta.columns['user'].cql_type
    assert False == meta.columns['user'].is_static
    assert 'int' == meta.columns['balance'].cql_type
    assert True == meta.columns['balance'].is_static
    assert 'int' == meta.columns['expense_id'].cql_type
    assert False == meta.columns['expense_id'].is_static
    assert 'int' == meta.columns['amount'].cql_type
    assert False == meta.columns['amount'].is_static


def establish_collection_datatype_table(version, session, table_name_prefix=""):
    table_name = _cql_name_builder(table_name_prefix, "test_collection_datatypes")
    cql = '''
        CREATE TABLE {0} (
            id uuid PRIMARY KEY,
            a list<int>,
            b list<text>,
            c set<int>,
            d set<text>,
            e map<text, text>,
            f map<text, int>,'''

    if version > '2.1':
        cql += '''
            g frozen<list<int>>,
            h frozen<list<text>>,
            i frozen<set<int>>,
            j frozen<set<text>>,
            k frozen<map<text, text>>,
            l frozen<map<text, int>>'''

    cql += ')'

    session.execute(cql.format(table_name))


def verify_collection_datatype_table(created_on_version, current_version, keyspace, session, table_name_prefix=""):
    table_name = _cql_name_builder(table_name_prefix, "test_collection_datatypes")
    meta = session.cluster.metadata.keyspaces[keyspace].tables[table_name]
    if created_on_version > '2.1':
        assert 13 == len(meta.columns)
    else:
        assert 7 == len(meta.columns)

    assert 'list<int>' == meta.columns['a'].cql_type
    assert 'list<text>' == meta.columns['b'].cql_type
    assert 'set<int>' == meta.columns['c'].cql_type
    assert 'set<text>' == meta.columns['d'].cql_type
    assert 'map<text, text>' == meta.columns['e'].cql_type
    assert 'map<text, int>' == meta.columns['f'].cql_type

    if created_on_version > '2.1':
        assert 'frozen<list<int>>' == meta.columns['g'].cql_type
        assert 'frozen<list<text>>' == meta.columns['h'].cql_type
        assert 'frozen<set<int>>' == meta.columns['i'].cql_type
        assert 'frozen<set<text>>' == meta.columns['j'].cql_type
        assert 'frozen<map<text, text>>' == meta.columns['k'].cql_type
        assert 'frozen<map<text, int>>' == meta.columns['l'].cql_type


def establish_basic_datatype_table(version, session, table_name_prefix=""):
    table_name = _cql_name_builder(table_name_prefix, "test_basic_datatypes")
    cql = '''
        CREATE TABLE {0} (
            a ascii,
            b bigint PRIMARY KEY,
            c blob,
            d boolean,
            e decimal,
            f double,
            g float,
            h inet,
            i int,
            j text,
            k timestamp,
            l timeuuid,
            m uuid,
            n varchar,
            o varint,'''
    if version > '2.2':
        cql += ''' p date,
                   q smallint,
                   r time,
                   s tinyint'''

    cql += ')'

    session.execute(cql.format(table_name))


def verify_basic_datatype_table(created_on_version, current_version, keyspace, session, table_name_prefix=""):
    table_name = _cql_name_builder(table_name_prefix, "test_basic_datatypes")
    meta = session.cluster.metadata.keyspaces[keyspace].tables[table_name]
    if created_on_version > '2.2':
        assert 19 == len(meta.columns)
    else:
        assert 15 == len(meta.columns)

    assert 1 == len(meta.primary_key)
    assert 'b' == meta.primary_key[0].name

    assert 'ascii' == meta.columns['a'].cql_type
    assert 'bigint' == meta.columns['b'].cql_type
    assert 'blob' == meta.columns['c'].cql_type
    assert 'boolean' == meta.columns['d'].cql_type
    assert 'decimal' == meta.columns['e'].cql_type
    assert 'double' == meta.columns['f'].cql_type
    assert 'float' == meta.columns['g'].cql_type
    assert 'inet' == meta.columns['h'].cql_type
    assert 'int' == meta.columns['i'].cql_type
    assert 'text' == meta.columns['j'].cql_type
    assert 'timestamp' == meta.columns['k'].cql_type
    assert 'timeuuid' == meta.columns['l'].cql_type
    assert 'uuid' == meta.columns['m'].cql_type
    assert 'text' == meta.columns['n'].cql_type
    assert 'varint' == meta.columns['o'].cql_type
    if created_on_version > '2.2':
        assert 'date' == meta.columns['p'].cql_type
        assert 'smallint' == meta.columns['q'].cql_type
        assert 'time' == meta.columns['r'].cql_type
        assert 'tinyint' == meta.columns['s'].cql_type


def _cql_name_builder(prefix, table_name):
    def get_uuid_str():
        return str(uuid4()).replace('-', '')
    try:
        consistent_hasher = _cql_name_builder.consistent_hasher
    except AttributeError:
        consistent_hasher = defaultdict(get_uuid_str)
        _cql_name_builder.consistent_hasher = consistent_hasher

    return "gen_{}".format(consistent_hasher[prefix + table_name])  # 'gen' as in 'generated'


class TestSchemaMetadata(Tester):
    @pytest.fixture(scope='function', autouse=True)
    def fixture_set_cluster_settings(self, fixture_dtest_setup):
        cluster = fixture_dtest_setup.cluster
        cluster.schema_event_refresh_window = 0

        if cluster.version() >= '4.2':
            cluster.set_configuration_options({'enable_user_defined_functions': 'true'})
        elif cluster.version() >= '3.0':
            cluster.set_configuration_options({'enable_user_defined_functions': 'true',
                                               'enable_scripted_user_defined_functions': 'true'})
        elif cluster.version() >= '2.2':
            cluster.set_configuration_options({'enable_user_defined_functions': 'true'})
        cluster.populate(1).start()

        self.session = fixture_dtest_setup.patient_cql_connection(cluster.nodelist()[0])
        create_ks(self.session, 'ks', 1)

    def _keyspace_meta(self, keyspace_name="ks"):
        self.session.cluster.refresh_schema_metadata()
        return self.session.cluster.metadata.keyspaces[keyspace_name]

    def test_creating_and_dropping_keyspace(self):
        starting_keyspace_count = len(self.session.cluster.metadata.keyspaces)
        assert True == self._keyspace_meta().durable_writes
        self.session.execute("""
                CREATE KEYSPACE so_long
                    WITH replication = {'class': 'SimpleStrategy', 'replication_factor': 1}
                    AND durable_writes = false
            """)
        assert False == self._keyspace_meta('so_long').durable_writes
        self.session.execute("DROP KEYSPACE so_long")
        assert starting_keyspace_count == len(self.session.cluster.metadata.keyspaces)

    def test_creating_and_dropping_table(self):
        self.session.execute("create table born_to_die (id uuid primary key, name varchar)")
        meta = self._keyspace_meta().tables['born_to_die']
        assert 'ks' == meta.keyspace_name
        assert 'born_to_die' == meta.name
        assert 1 == len(meta.partition_key)
        assert 'id' == meta.partition_key[0].name
        assert 2 == len(meta.columns)
        assert meta.columns.get('id') is not None
        assert 'uuid' == meta.columns['id'].cql_type
        assert meta.columns.get('name') is not None
        assert 'text' == meta.columns['name'].cql_type
        assert 0 == len(meta.clustering_key)
        assert 0 == len(meta.triggers)
        assert 0 == len(meta.indexes)
        self.session.execute("drop table born_to_die")
        assert self._keyspace_meta().tables.get('born_to_die') is None

    def test_creating_and_dropping_table_with_2ary_indexes(self):
        assert 0 == len(self._keyspace_meta().indexes)
        self.session.execute("create table born_to_die (id uuid primary key, name varchar)")
        self.session.execute("create index ix_born_to_die_name on born_to_die(name)")

        assert 1 == len(self._keyspace_meta().indexes)
        ix_meta = self._keyspace_meta().indexes['ix_born_to_die_name']
        assert 'ix_born_to_die_name' == ix_meta.name

        opts = dict(ix_meta.index_options)
        # When SAI is the default index class, we get a somewhat different configuration.
        if 'class_name' in opts:
            opts = { k : opts[k] for k in set(opts) - {'class_name'} }
            assert 'CUSTOM' == ix_meta.kind
        else:
            assert 'COMPOSITES' == ix_meta.kind

        assert {'target': 'name'} == opts

        self.session.execute("drop table born_to_die")
        assert self._keyspace_meta().tables.get('born_to_die') is None
        assert self._keyspace_meta().indexes.get('ix_born_to_die_name') is None
        assert 0 == len(self._keyspace_meta().indexes)

    @since('2.1')
    def test_creating_and_dropping_user_types(self):
        assert 0 == len(self._keyspace_meta().user_types)
        self.session.execute("CREATE TYPE soon_to_die (foo text, bar int)")
        assert 1 == len(self._keyspace_meta().user_types)

        ut_meta = self._keyspace_meta().user_types['soon_to_die']
        assert 'ks' == ut_meta.keyspace
        assert 'soon_to_die' == ut_meta.name
        assert ['foo', 'bar'] == ut_meta.field_names
        assert ['text', 'int'] == ut_meta.field_types

        self.session.execute("DROP TYPE soon_to_die")
        assert 0 == len(self._keyspace_meta().user_types)

    @since('2.2')
    def test_creating_and_dropping_udf(self):
        assert 0 == len(self._keyspace_meta().functions), "expected to start with no indexes"
        self.session.execute("""
                CREATE OR REPLACE FUNCTION ks.wasteful_function (input double)
                    CALLED ON NULL INPUT
                    RETURNS double
                    LANGUAGE java AS 'return Double.valueOf(Math.log(input.doubleValue()));';
            """)
        assert 1 == len(self._keyspace_meta().functions), "udf count should be 1"
        udf_meta = self._keyspace_meta().functions['wasteful_function(double)']
        assert 'ks' == udf_meta.keyspace
        assert 'wasteful_function' == udf_meta.name
        assert ['double'] == udf_meta.argument_types
        assert ['input'] == udf_meta.argument_names
        assert 'double' == udf_meta.return_type
        assert 'java' == udf_meta.language
        assert 'return Double.valueOf(Math.log(input.doubleValue()));' == udf_meta.body
        assert udf_meta.called_on_null_input
        self.session.execute("DROP FUNCTION ks.wasteful_function")
        assert 0 == len(self._keyspace_meta().functions), "expected udf list to be back to zero"

    @since('2.2')
    def test_creating_and_dropping_uda(self):
        assert 0 == len(self._keyspace_meta().functions), "expected to start with no indexes"
        assert 0 == len(self._keyspace_meta().aggregates), "expected to start with no aggregates"
        self.session.execute('''
                CREATE FUNCTION ks.max_val(current int, candidate int)
                CALLED ON NULL INPUT
                RETURNS int LANGUAGE java AS
                'if (current == null) return candidate; else return Math.max(current, candidate);'
            ''')
        self.session.execute('''
                CREATE AGGREGATE ks.kind_of_max_agg(int)
                SFUNC max_val
                STYPE int
                INITCOND -1
            ''')
        assert 1 == len(self._keyspace_meta().functions), "udf count should be 1"
        assert 1 == len(self._keyspace_meta().aggregates), "uda count should be 1"
        udf_meta = self._keyspace_meta().functions['max_val(int,int)']
        uda_meta = self._keyspace_meta().aggregates['kind_of_max_agg(int)']

        assert 'ks' == udf_meta.keyspace
        assert 'max_val' == udf_meta.name
        assert ['int', 'int'] == udf_meta.argument_types
        assert ['current', 'candidate'] == udf_meta.argument_names
        assert 'int' == udf_meta.return_type
        assert 'java' == udf_meta.language
        assert 'if (current == null) return candidate; else return Math.max(current, candidate);' == udf_meta.body
        assert udf_meta.called_on_null_input

        assert 'ks' == uda_meta.keyspace
        assert 'kind_of_max_agg' == uda_meta.name
        assert ['int'] == uda_meta.argument_types
        assert 'max_val' == uda_meta.state_func
        assert 'int' == uda_meta.state_type
        assert None == uda_meta.final_func
        assert '-1' == uda_meta.initial_condition
        assert 'int' == uda_meta.return_type

        self.session.execute("DROP AGGREGATE ks.kind_of_max_agg")
        assert 0 == len(self._keyspace_meta().aggregates), "expected uda list to be back to zero"
        self.session.execute("DROP FUNCTION ks.max_val")
        assert 0 == len(self._keyspace_meta().functions), "expected udf list to be back to zero"

    def test_basic_table_datatype(self):
        establish_basic_datatype_table(self.cluster.version(), self.session)
        verify_basic_datatype_table(self.cluster.version(), self.cluster.version(), 'ks', self.session)

    def test_collection_table_datatype(self):
        establish_collection_datatype_table(self.cluster.version(), self.session)
        verify_collection_datatype_table(self.cluster.version(), self.cluster.version(), 'ks', self.session)

    def test_clustering_order(self):
        establish_clustering_order_table(self.cluster.version(), self.session)
        verify_clustering_order_table(self.cluster.version(), self.cluster.version(), 'ks', self.session)

    @since("2.0", max_version="3.X")  # Compact Storage
    def test_compact_storage(self):
        establish_compact_storage_table(self.cluster.version(), self.session)
        verify_compact_storage_table(self.cluster.version(), self.cluster.version(), 'ks', self.session)

    @since("2.0", max_version="3.X")  # Compact Storage
    def test_compact_storage_composite(self):
        establish_compact_storage_composite_table(self.cluster.version(), self.session)
        verify_compact_storage_composite_table(self.cluster.version(), self.cluster.version(), 'ks', self.session)

    def test_nondefault_table_settings(self):
        establish_nondefault_table_settings(self.cluster.version(), self.session)
        verify_nondefault_table_settings(self.cluster.version(), self.cluster.version(), 'ks', self.session)

    def test_indexes(self):
        establish_indexes_table(self.cluster.version(), self.session)
        verify_indexes_table(self.cluster.version(), self.cluster.version(), 'ks', self.session)

    def test_durable_writes(self):
        establish_durable_writes_keyspace(self.cluster.version(), self.session)
        verify_durable_writes_keyspace(self.cluster.version(), self.cluster.version(), 'ks', self.session)

    @since('2.0')
    def test_static_column(self):
        establish_static_column_table(self.cluster.version(), self.session)
        verify_static_column_table(self.cluster.version(), self.cluster.version(), 'ks', self.session)

    @since('2.1')
    def test_udt_table(self):
        establish_udt_table(self.cluster.version(), self.session)
        verify_udt_table(self.cluster.version(), self.cluster.version(), 'ks', self.session)

    @since('2.2')
    def test_udf(self):
        establish_udf(self.cluster.version(), self.session)
        self.session.cluster.refresh_schema_metadata()
        verify_udf(self.cluster.version(), self.cluster.version(), 'ks', self.session)

    @since('2.2')
    def test_uda(self):
        establish_uda(self.cluster.version(), self.session)
        self.session.cluster.refresh_schema_metadata()
        verify_uda(self.cluster.version(), self.cluster.version(), 'ks', self.session)