def test_collection_indexes(self): if get_server_versions()[0] < (2, 1, 0): raise unittest.SkipTest("Secondary index on collections were introduced in Cassandra 2.1") self.session.execute("CREATE TABLE %s.%s (a int PRIMARY KEY, b map<text, text>)" % (self.ksname, self.cfname)) self.session.execute("CREATE INDEX index1 ON %s.%s (keys(b))" % (self.ksname, self.cfname)) tablemeta = self.get_table_metadata() self.assertIn('(keys(b))', tablemeta.export_as_string()) self.session.execute("DROP INDEX %s.index1" % (self.ksname,)) self.session.execute("CREATE INDEX index2 ON %s.%s (b)" % (self.ksname, self.cfname)) tablemeta = self.get_table_metadata() self.assertIn(' (b)', tablemeta.export_as_string()) # test full indexes on frozen collections, if available if get_server_versions()[0] >= (2, 1, 3): self.session.execute("DROP TABLE %s.%s" % (self.ksname, self.cfname)) self.session.execute("CREATE TABLE %s.%s (a int PRIMARY KEY, b frozen<map<text, text>>)" % (self.ksname, self.cfname)) self.session.execute("CREATE INDEX index3 ON %s.%s (full(b))" % (self.ksname, self.cfname)) tablemeta = self.get_table_metadata() self.assertIn('(full(b))', tablemeta.export_as_string())
def test_refresh_schema_type(self): if get_server_versions()[0] < (2, 1, 0): raise unittest.SkipTest('UDTs were introduced in Cassandra 2.1') if PROTOCOL_VERSION < 3: raise unittest.SkipTest( 'UDTs are not specified in change events for protocol v2') # We may want to refresh types on keyspace change events in that case(?) cluster = Cluster(protocol_version=PROTOCOL_VERSION) session = cluster.connect() keyspace_name = 'test1rf' type_name = self._testMethodName execute_until_pass( session, 'CREATE TYPE IF NOT EXISTS %s.%s (one int, two text)' % (keyspace_name, type_name)) original_meta = cluster.metadata.keyspaces original_test1rf_meta = original_meta[keyspace_name] original_type_meta = original_test1rf_meta.user_types[type_name] # only refresh one type cluster.refresh_user_type_metadata('test1rf', type_name) current_meta = cluster.metadata.keyspaces current_test1rf_meta = current_meta[keyspace_name] current_type_meta = current_test1rf_meta.user_types[type_name] self.assertIs(original_meta, current_meta) self.assertEqual(original_test1rf_meta.export_as_string(), current_test1rf_meta.export_as_string()) self.assertIsNot(original_type_meta, current_type_meta) self.assertEqual(original_type_meta.as_cql_query(), current_type_meta.as_cql_query()) session.shutdown()
def session_setup(self): lbp = DSELoadBalancingPolicy(default_lbp_factory()) ep_graphson2 = GraphExecutionProfile( request_timeout=60, load_balancing_policy=lbp, graph_options=GraphOptions( graph_name=self.graph_name, graph_protocol=GraphProtocol.GRAPHSON_2_0), row_factory=graph_graphson2_row_factory) ep_graphson1 = GraphExecutionProfile( request_timeout=60, load_balancing_policy=lbp, graph_options=GraphOptions(graph_name=self.graph_name)) ep_analytics = GraphAnalyticsExecutionProfile( request_timeout=60, load_balancing_policy=lbp, graph_options=GraphOptions(graph_language=b'gremlin-groovy', graph_name=self.graph_name)) self.cluster = Cluster(protocol_version=PROTOCOL_VERSION, execution_profiles={ EXEC_PROFILE_GRAPH_DEFAULT: ep_graphson1, EXEC_PROFILE_GRAPH_ANALYTICS_DEFAULT: ep_analytics, "graphson2": ep_graphson2 }) self.session = self.cluster.connect() self.ks_name = self._testMethodName.lower() self.cass_version, self.cql_version = get_server_versions()
def test_refresh_schema_type(self): if get_server_versions()[0] < (2, 1, 0): raise unittest.SkipTest('UDTs were introduced in Cassandra 2.1') if PROTOCOL_VERSION < 3: raise unittest.SkipTest('UDTs are not specified in change events for protocol v2') # We may want to refresh types on keyspace change events in that case(?) cluster = Cluster(protocol_version=PROTOCOL_VERSION) session = cluster.connect() keyspace_name = 'test1rf' type_name = self._testMethodName session.execute('CREATE TYPE IF NOT EXISTS %s.%s (one int, two text)' % (keyspace_name, type_name)) original_meta = cluster.metadata.keyspaces original_test1rf_meta = original_meta[keyspace_name] original_type_meta = original_test1rf_meta.user_types[type_name] # only refresh one type cluster.refresh_user_type_metadata('test1rf', type_name) current_meta = cluster.metadata.keyspaces current_test1rf_meta = current_meta[keyspace_name] current_type_meta = current_test1rf_meta.user_types[type_name] self.assertIs(original_meta, current_meta) self.assertIs(original_test1rf_meta, current_test1rf_meta) self.assertIsNot(original_type_meta, current_type_meta) self.assertEqual(original_type_meta.as_cql_query(), current_type_meta.as_cql_query()) session.shutdown()
def setUp(self): self._cass_version, self._cql_version = get_server_versions() self.cluster = Cluster(protocol_version=PROTOCOL_VERSION) self.session = self.cluster.connect() self.session.execute("CREATE KEYSPACE typetests WITH replication = { 'class' : 'SimpleStrategy', 'replication_factor': '1'}") self.cluster.shutdown()
def setup_class(cls): cls.cluster = TestCluster() cls.session = cls.cluster.connect() cls._cass_version, cls._cql_version = get_server_versions() ddl = ''' CREATE TABLE test1rf.table_num_col ( key blob PRIMARY KEY, "626972746864617465" blob )''' cls.session.execute(ddl)
def setup_class(cls): cls._cass_version, cls._cql_version = get_server_versions() cls._col_types = ['text', 'ascii', 'bigint', 'boolean', 'decimal', 'double', 'float', 'inet', 'int', 'list<text>', 'set<int>', 'map<text,int>', 'timestamp', 'uuid', 'timeuuid', 'varchar', 'varint'] if cls._cass_version >= (2, 1, 4): cls._col_types.extend(('date', 'time')) cls._session = Cluster(protocol_version=PROTOCOL_VERSION).connect() cls._session.execute("CREATE KEYSPACE typetests WITH replication = { 'class' : 'SimpleStrategy', 'replication_factor': '1'}") cls._session.set_keyspace("typetests")
def setup_class(cls): cls.cluster = Cluster(protocol_version=PROTOCOL_VERSION) cls.session = cls.cluster.connect() cls._cass_version, cls._cql_version = get_server_versions() ddl = ''' CREATE TABLE test1rf.table_num_col ( key blob PRIMARY KEY, "626972746864617465" blob ) WITH COMPACT STORAGE''' cls.session.execute(ddl)
def common_dse_setup(cls, rf, keyspace_creation=True): cls.cluster = Cluster(protocol_version=PROTOCOL_VERSION) cls.session = cls.cluster.connect() cls.ks_name = cls.__name__.lower() if keyspace_creation: cls.create_keyspace(rf) cls.cass_version, cls.cql_version = get_server_versions() cls.session.set_keyspace(cls.ks_name)
def update_datatypes(): _cass_version, _cql_version = get_server_versions() if _cass_version >= (2, 1, 0): COLLECTION_TYPES.append('tuple') if _cass_version >= (2, 1, 5): PRIMITIVE_DATATYPES.append('date') PRIMITIVE_DATATYPES.append('time')
def setUp(self): self._cass_version, self._cql_version = get_server_versions() if self._cass_version < (2, 1, 0): raise unittest.SkipTest("User Defined Types were introduced in Cassandra 2.1") self.cluster = Cluster(protocol_version=PROTOCOL_VERSION) self.session = self.cluster.connect() self.session.execute("CREATE KEYSPACE udttests WITH replication = { 'class' : 'SimpleStrategy', 'replication_factor': '1'}") self.cluster.shutdown()
def update_datatypes(): _cass_version, _cql_version = get_server_versions() if _cass_version >= (2, 1, 0): COLLECTION_TYPES.add('tuple') if _cass_version >= (2, 2, 0): PRIMITIVE_DATATYPES.update(['date', 'time', 'smallint', 'tinyint']) global SAMPLE_DATA SAMPLE_DATA = get_sample_data()
def update_datatypes(): _cass_version, _cql_version = get_server_versions() if _cass_version >= (2, 1, 0): COLLECTION_TYPES.add("tuple") if _cass_version >= (2, 2, 0): PRIMITIVE_DATATYPES.update(["date", "time", "smallint", "tinyint"]) global SAMPLE_DATA SAMPLE_DATA = get_sample_data()
def setup_module(): use_singledc(start=False) ccm_cluster = get_cluster() ccm_cluster.clear() # This is necessary because test_too_many_statements may # timeout otherwise config_options = {'write_request_timeout_in_ms': '20000'} ccm_cluster.set_configuration_options(config_options) ccm_cluster.start(wait_for_binary_proto=True, wait_other_notice=True) setup_keyspace() global CASS_SERVER_VERSION CASS_SERVER_VERSION = get_server_versions()[0]
def setUp(self): self._cass_version, self._cql_version = get_server_versions() if self._cass_version < (2, 1, 0): raise unittest.SkipTest( "User Defined Types were introduced in Cassandra 2.1") self.cluster = Cluster(protocol_version=PROTOCOL_VERSION) self.session = self.cluster.connect() execute_until_pass( self.session, "CREATE KEYSPACE udttests WITH replication = { 'class' : 'SimpleStrategy', 'replication_factor': '1'}" ) self.cluster.shutdown()
def test_collection_indexes(self): self.session.execute("CREATE TABLE %s.%s (a int PRIMARY KEY, b map<text, text>)" % (self.ksname, self.cfname)) self.session.execute("CREATE INDEX index1 ON %s.%s (keys(b))" % (self.ksname, self.cfname)) tablemeta = self.get_table_metadata() self.assertIn("(keys(b))", tablemeta.export_as_string()) self.session.execute("DROP INDEX %s.index1" % (self.ksname,)) self.session.execute("CREATE INDEX index2 ON %s.%s (b)" % (self.ksname, self.cfname)) tablemeta = self.get_table_metadata() self.assertIn(" (b)", tablemeta.export_as_string()) # test full indexes on frozen collections, if available if get_server_versions()[0] >= (2, 1, 3): self.session.execute("DROP TABLE %s.%s" % (self.ksname, self.cfname)) self.session.execute( "CREATE TABLE %s.%s (a int PRIMARY KEY, b frozen<map<text, text>>)" % (self.ksname, self.cfname) ) self.session.execute("CREATE INDEX index3 ON %s.%s (full(b))" % (self.ksname, self.cfname)) tablemeta = self.get_table_metadata() self.assertIn("(full(b))", tablemeta.export_as_string())
def test_export_keyspace_schema_udts(self): """ Test udt exports """ if get_server_versions()[0] < (2, 1, 0): raise unittest.SkipTest('UDTs were introduced in Cassandra 2.1') cluster = Cluster(protocol_version=PROTOCOL_VERSION) session = cluster.connect() session.execute(""" CREATE KEYSPACE export_udts WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '1'} AND durable_writes = true; """) session.execute(""" CREATE TYPE export_udts.street ( street_number int, street_name text) """) session.execute(""" CREATE TYPE export_udts.zip ( zipcode int, zip_plus_4 int) """) session.execute(""" CREATE TYPE export_udts.address ( street_address street, zip_code zip) """) session.execute(""" CREATE TABLE export_udts.users ( user text PRIMARY KEY, addresses map<text, address>) """) expected_string = """CREATE KEYSPACE export_udts WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '1'} AND durable_writes = true; CREATE TYPE export_udts.street ( street_number int, street_name text ); CREATE TYPE export_udts.zip ( zipcode int, zip_plus_4 int ); CREATE TYPE export_udts.address ( street_address street, zip_code zip ); CREATE TABLE export_udts.users ( user text PRIMARY KEY, addresses map<text, address> ) WITH bloom_filter_fp_chance = 0.01 AND caching = '{"keys":"ALL", "rows_per_partition":"NONE"}' AND comment = '' AND compaction = {'min_threshold': '4', 'class': 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy', 'max_threshold': '32'} AND compression = {'sstable_compression': 'org.apache.cassandra.io.compress.LZ4Compressor'} AND dclocal_read_repair_chance = 0.1 AND default_time_to_live = 0 AND gc_grace_seconds = 864000 AND max_index_interval = 2048 AND memtable_flush_period_in_ms = 0 AND min_index_interval = 128 AND read_repair_chance = 0.0 AND speculative_retry = '99.0PERCENTILE';""" self.assertEqual( cluster.metadata.keyspaces['export_udts'].export_as_string(), expected_string) table_meta = cluster.metadata.keyspaces['export_udts'].tables['users'] expected_string = """CREATE TABLE export_udts.users ( user text PRIMARY KEY, addresses map<text, address> ) WITH bloom_filter_fp_chance = 0.01 AND caching = '{"keys":"ALL", "rows_per_partition":"NONE"}' AND comment = '' AND compaction = {'min_threshold': '4', 'class': 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy', 'max_threshold': '32'} AND compression = {'sstable_compression': 'org.apache.cassandra.io.compress.LZ4Compressor'} AND dclocal_read_repair_chance = 0.1 AND default_time_to_live = 0 AND gc_grace_seconds = 864000 AND max_index_interval = 2048 AND memtable_flush_period_in_ms = 0 AND min_index_interval = 128 AND read_repair_chance = 0.0 AND speculative_retry = '99.0PERCENTILE';""" self.assertEqual(table_meta.export_as_string(), expected_string)
def is_prepend_reversed(): # do we have https://issues.apache.org/jira/browse/CASSANDRA-8733 ? ver, _ = get_server_versions() return not (ver >= (2, 0, 13) or ver >= (2, 1, 3))
def setUp(self): if PROTOCOL_VERSION < 3: raise unittest.SkipTest("v3 protocol is required for UDT tests") self._cass_version, self._cql_version = get_server_versions()
def session_setup(cls): cls.cluster = Cluster(protocol_version=PROTOCOL_VERSION) cls.session = cls.cluster.connect() cls.ks_name = cls.__name__.lower() cls.cass_version, cls.cql_version = get_server_versions() cls.graph_name = cls.__name__.lower()
def setUp(self): self._cass_version, self._cql_version = get_server_versions()
def test_export_keyspace_schema_udts(self): """ Test udt exports """ if get_server_versions()[0] < (2, 1, 0): raise unittest.SkipTest('UDTs were introduced in Cassandra 2.1') if PROTOCOL_VERSION < 3: raise unittest.SkipTest( "Protocol 3.0+ is required for UDT change events, currently testing against %r" % (PROTOCOL_VERSION,)) if sys.version_info[0:2] != (2, 7): raise unittest.SkipTest('This test compares static strings generated from dict items, which may change orders. Test with 2.7.') cluster = Cluster(protocol_version=PROTOCOL_VERSION) session = cluster.connect() session.execute(""" CREATE KEYSPACE export_udts WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '1'} AND durable_writes = true; """) session.execute(""" CREATE TYPE export_udts.street ( street_number int, street_name text) """) session.execute(""" CREATE TYPE export_udts.zip ( zipcode int, zip_plus_4 int) """) session.execute(""" CREATE TYPE export_udts.address ( street_address frozen<street>, zip_code frozen<zip>) """) session.execute(""" CREATE TABLE export_udts.users ( user text PRIMARY KEY, addresses map<text, frozen<address>>) """) expected_string = """CREATE KEYSPACE export_udts WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '1'} AND durable_writes = true; CREATE TYPE export_udts.street ( street_number int, street_name text ); CREATE TYPE export_udts.zip ( zipcode int, zip_plus_4 int ); CREATE TYPE export_udts.address ( street_address frozen<street>, zip_code frozen<zip> ); CREATE TABLE export_udts.users ( user text PRIMARY KEY, addresses map<text, frozen<address>> ) WITH bloom_filter_fp_chance = 0.01 AND caching = '{"keys":"ALL", "rows_per_partition":"NONE"}' AND comment = '' AND compaction = {'min_threshold': '4', 'class': 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy', 'max_threshold': '32'} AND compression = {'sstable_compression': 'org.apache.cassandra.io.compress.LZ4Compressor'} AND dclocal_read_repair_chance = 0.1 AND default_time_to_live = 0 AND gc_grace_seconds = 864000 AND max_index_interval = 2048 AND memtable_flush_period_in_ms = 0 AND min_index_interval = 128 AND read_repair_chance = 0.0 AND speculative_retry = '99.0PERCENTILE';""" self.assert_equal_diff(cluster.metadata.keyspaces['export_udts'].export_as_string(), expected_string) table_meta = cluster.metadata.keyspaces['export_udts'].tables['users'] expected_string = """CREATE TABLE export_udts.users ( user text PRIMARY KEY, addresses map<text, frozen<address>> ) WITH bloom_filter_fp_chance = 0.01 AND caching = '{"keys":"ALL", "rows_per_partition":"NONE"}' AND comment = '' AND compaction = {'min_threshold': '4', 'class': 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy', 'max_threshold': '32'} AND compression = {'sstable_compression': 'org.apache.cassandra.io.compress.LZ4Compressor'} AND dclocal_read_repair_chance = 0.1 AND default_time_to_live = 0 AND gc_grace_seconds = 864000 AND max_index_interval = 2048 AND memtable_flush_period_in_ms = 0 AND min_index_interval = 128 AND read_repair_chance = 0.0 AND speculative_retry = '99.0PERCENTILE';""" self.assert_equal_diff(table_meta.export_as_string(), expected_string) cluster.shutdown()
def setUpClass(cls): cls._cass_version, cls._cql_version = get_server_versions() cls.cluster = Cluster(protocol_version=PROTOCOL_VERSION) cls.session = cls.cluster.connect() cls.session.execute("CREATE KEYSPACE typetests WITH replication = { 'class' : 'SimpleStrategy', 'replication_factor': '1'}") cls.session.set_keyspace("typetests")
def setup_module(): use_singledc() global CASS_SERVER_VERSION CASS_SERVER_VERSION = get_server_versions()[0]
def setUpClass(self): if get_server_versions()[0] < (2, 1, 0): raise unittest.SkipTest("UDTs require Cassandra 2.1 or greater")
def test_legacy_tables(self): if get_server_versions()[0] < (2, 1, 0): raise unittest.SkipTest('Test schema output assumes 2.1.0+ options') if sys.version_info[0:2] != (2, 7): raise unittest.SkipTest('This test compares static strings generated from dict items, which may change orders. Test with 2.7.') cli_script = """CREATE KEYSPACE legacy WITH placement_strategy = 'SimpleStrategy' AND strategy_options = {replication_factor:1}; USE legacy; CREATE COLUMN FAMILY simple_no_col WITH comparator = UTF8Type AND key_validation_class = UUIDType AND default_validation_class = UTF8Type; CREATE COLUMN FAMILY simple_with_col WITH comparator = UTF8Type and key_validation_class = UUIDType and default_validation_class = UTF8Type AND column_metadata = [ {column_name: col_with_meta, validation_class: UTF8Type} ]; CREATE COLUMN FAMILY composite_partition_no_col WITH comparator = UTF8Type AND key_validation_class = 'CompositeType(UUIDType,UTF8Type)' AND default_validation_class = UTF8Type; CREATE COLUMN FAMILY composite_partition_with_col WITH comparator = UTF8Type AND key_validation_class = 'CompositeType(UUIDType,UTF8Type)' AND default_validation_class = UTF8Type AND column_metadata = [ {column_name: col_with_meta, validation_class: UTF8Type} ]; CREATE COLUMN FAMILY nested_composite_key WITH comparator = UTF8Type and key_validation_class = 'CompositeType(CompositeType(UUIDType,UTF8Type), LongType)' and default_validation_class = UTF8Type AND column_metadata = [ {column_name: full_name, validation_class: UTF8Type} ]; create column family composite_comp_no_col with column_type = 'Standard' and comparator = 'DynamicCompositeType(t=>org.apache.cassandra.db.marshal.TimeUUIDType,s=>org.apache.cassandra.db.marshal.UTF8Type,b=>org.apache.cassandra.db.marshal.BytesType)' and default_validation_class = 'BytesType' and key_validation_class = 'BytesType' and read_repair_chance = 0.0 and dclocal_read_repair_chance = 0.1 and gc_grace = 864000 and min_compaction_threshold = 4 and max_compaction_threshold = 32 and compaction_strategy = 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy' and caching = 'KEYS_ONLY' and cells_per_row_to_cache = '0' and default_time_to_live = 0 and speculative_retry = 'NONE' and comment = 'Stores file meta data'; create column family composite_comp_with_col with column_type = 'Standard' and comparator = 'DynamicCompositeType(t=>org.apache.cassandra.db.marshal.TimeUUIDType,s=>org.apache.cassandra.db.marshal.UTF8Type,b=>org.apache.cassandra.db.marshal.BytesType)' and default_validation_class = 'BytesType' and key_validation_class = 'BytesType' and read_repair_chance = 0.0 and dclocal_read_repair_chance = 0.1 and gc_grace = 864000 and min_compaction_threshold = 4 and max_compaction_threshold = 32 and compaction_strategy = 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy' and caching = 'KEYS_ONLY' and cells_per_row_to_cache = '0' and default_time_to_live = 0 and speculative_retry = 'NONE' and comment = 'Stores file meta data' and column_metadata = [ {column_name : 'b@6d616d6d616a616d6d61', validation_class : BytesType, index_name : 'idx_one', index_type : 0}, {column_name : 'b@6869746d65776974686d75736963', validation_class : BytesType, index_name : 'idx_two', index_type : 0}] and compression_options = {'sstable_compression' : 'org.apache.cassandra.io.compress.LZ4Compressor'};""" # note: the inner key type for legacy.nested_composite_key # (org.apache.cassandra.db.marshal.CompositeType(org.apache.cassandra.db.marshal.UUIDType, org.apache.cassandra.db.marshal.UTF8Type)) # is a bit strange, but it replays in CQL with desired results expected_string = """CREATE KEYSPACE legacy WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '1'} AND durable_writes = true; /* Warning: Table legacy.composite_comp_with_col omitted because it has constructs not compatible with CQL (was created via legacy API). Approximate structure, for reference: (this should not be used to reproduce this schema) CREATE TABLE legacy.composite_comp_with_col ( key blob, t timeuuid, b blob, s text, "b@6869746d65776974686d75736963" blob, "b@6d616d6d616a616d6d61" blob, PRIMARY KEY (key, t, b, s) ) WITH COMPACT STORAGE AND CLUSTERING ORDER BY (t ASC, b ASC, s ASC) AND caching = '{"keys":"ALL", "rows_per_partition":"NONE"}' AND comment = 'Stores file meta data' AND compaction = {'min_threshold': '4', 'class': 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy', 'max_threshold': '32'} AND compression = {'sstable_compression': 'org.apache.cassandra.io.compress.LZ4Compressor'} AND dclocal_read_repair_chance = 0.1 AND default_time_to_live = 0 AND gc_grace_seconds = 864000 AND max_index_interval = 2048 AND memtable_flush_period_in_ms = 0 AND min_index_interval = 128 AND read_repair_chance = 0.0 AND speculative_retry = 'NONE'; CREATE INDEX idx_two ON legacy.composite_comp_with_col ("b@6869746d65776974686d75736963"); CREATE INDEX idx_one ON legacy.composite_comp_with_col ("b@6d616d6d616a616d6d61"); */ CREATE TABLE legacy.nested_composite_key ( key 'org.apache.cassandra.db.marshal.CompositeType(org.apache.cassandra.db.marshal.UUIDType, org.apache.cassandra.db.marshal.UTF8Type)', key2 bigint, full_name text, PRIMARY KEY ((key, key2)) ) WITH COMPACT STORAGE AND caching = '{"keys":"ALL", "rows_per_partition":"NONE"}' AND comment = '' AND compaction = {'min_threshold': '4', 'class': 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy', 'max_threshold': '32'} AND compression = {'sstable_compression': 'org.apache.cassandra.io.compress.LZ4Compressor'} AND dclocal_read_repair_chance = 0.1 AND default_time_to_live = 0 AND gc_grace_seconds = 864000 AND max_index_interval = 2048 AND memtable_flush_period_in_ms = 0 AND min_index_interval = 128 AND read_repair_chance = 0.0 AND speculative_retry = 'NONE'; CREATE TABLE legacy.composite_partition_with_col ( key uuid, key2 text, col_with_meta text, PRIMARY KEY ((key, key2)) ) WITH COMPACT STORAGE AND caching = '{"keys":"ALL", "rows_per_partition":"NONE"}' AND comment = '' AND compaction = {'min_threshold': '4', 'class': 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy', 'max_threshold': '32'} AND compression = {'sstable_compression': 'org.apache.cassandra.io.compress.LZ4Compressor'} AND dclocal_read_repair_chance = 0.1 AND default_time_to_live = 0 AND gc_grace_seconds = 864000 AND max_index_interval = 2048 AND memtable_flush_period_in_ms = 0 AND min_index_interval = 128 AND read_repair_chance = 0.0 AND speculative_retry = 'NONE'; CREATE TABLE legacy.composite_partition_no_col ( key uuid, key2 text, column1 text, value text, PRIMARY KEY ((key, key2), column1) ) WITH COMPACT STORAGE AND CLUSTERING ORDER BY (column1 ASC) AND caching = '{"keys":"ALL", "rows_per_partition":"NONE"}' AND comment = '' AND compaction = {'min_threshold': '4', 'class': 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy', 'max_threshold': '32'} AND compression = {'sstable_compression': 'org.apache.cassandra.io.compress.LZ4Compressor'} AND dclocal_read_repair_chance = 0.1 AND default_time_to_live = 0 AND gc_grace_seconds = 864000 AND max_index_interval = 2048 AND memtable_flush_period_in_ms = 0 AND min_index_interval = 128 AND read_repair_chance = 0.0 AND speculative_retry = 'NONE'; CREATE TABLE legacy.simple_with_col ( key uuid PRIMARY KEY, col_with_meta text ) WITH COMPACT STORAGE AND caching = '{"keys":"ALL", "rows_per_partition":"NONE"}' AND comment = '' AND compaction = {'min_threshold': '4', 'class': 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy', 'max_threshold': '32'} AND compression = {'sstable_compression': 'org.apache.cassandra.io.compress.LZ4Compressor'} AND dclocal_read_repair_chance = 0.1 AND default_time_to_live = 0 AND gc_grace_seconds = 864000 AND max_index_interval = 2048 AND memtable_flush_period_in_ms = 0 AND min_index_interval = 128 AND read_repair_chance = 0.0 AND speculative_retry = 'NONE'; CREATE TABLE legacy.simple_no_col ( key uuid, column1 text, value text, PRIMARY KEY (key, column1) ) WITH COMPACT STORAGE AND CLUSTERING ORDER BY (column1 ASC) AND caching = '{"keys":"ALL", "rows_per_partition":"NONE"}' AND comment = '' AND compaction = {'min_threshold': '4', 'class': 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy', 'max_threshold': '32'} AND compression = {'sstable_compression': 'org.apache.cassandra.io.compress.LZ4Compressor'} AND dclocal_read_repair_chance = 0.1 AND default_time_to_live = 0 AND gc_grace_seconds = 864000 AND max_index_interval = 2048 AND memtable_flush_period_in_ms = 0 AND min_index_interval = 128 AND read_repair_chance = 0.0 AND speculative_retry = 'NONE'; /* Warning: Table legacy.composite_comp_no_col omitted because it has constructs not compatible with CQL (was created via legacy API). Approximate structure, for reference: (this should not be used to reproduce this schema) CREATE TABLE legacy.composite_comp_no_col ( key blob, column1 'org.apache.cassandra.db.marshal.DynamicCompositeType(org.apache.cassandra.db.marshal.TimeUUIDType, org.apache.cassandra.db.marshal.BytesType, org.apache.cassandra.db.marshal.UTF8Type)', column2 text, value blob, PRIMARY KEY (key, column1, column1, column2) ) WITH COMPACT STORAGE AND CLUSTERING ORDER BY (column1 ASC, column1 ASC, column2 ASC) AND caching = '{"keys":"ALL", "rows_per_partition":"NONE"}' AND comment = 'Stores file meta data' AND compaction = {'min_threshold': '4', 'class': 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy', 'max_threshold': '32'} AND compression = {'sstable_compression': 'org.apache.cassandra.io.compress.LZ4Compressor'} AND dclocal_read_repair_chance = 0.1 AND default_time_to_live = 0 AND gc_grace_seconds = 864000 AND max_index_interval = 2048 AND memtable_flush_period_in_ms = 0 AND min_index_interval = 128 AND read_repair_chance = 0.0 AND speculative_retry = 'NONE'; */""" ccm = get_cluster() ccm.run_cli(cli_script) cluster = Cluster(protocol_version=PROTOCOL_VERSION) session = cluster.connect() legacy_meta = cluster.metadata.keyspaces['legacy'] self.assert_equal_diff(legacy_meta.export_as_string(), expected_string) session.execute('DROP KEYSPACE legacy') cluster.shutdown()
def setUp(self): cass_version = get_server_versions()[0] if cass_version < (3, 0): raise unittest.SkipTest("Materialized views require Cassandra 3.0+") super(TestNamedWithMV, self).setUp()
def session_setup(self): self.cluster = Cluster(protocol_version=PROTOCOL_VERSION) self.session = self.cluster.connect() self.ks_name = self._testMethodName.lower() self.cass_version, self.cql_version = get_server_versions()
def test_export_keyspace_schema_udts(self): """ Test udt exports """ if get_server_versions()[0] < (2, 1, 0): raise unittest.SkipTest('UDTs were introduced in Cassandra 2.1') if PROTOCOL_VERSION < 3: raise unittest.SkipTest( "Protocol 3.0+ is required for UDT change events, currently testing against %r" % (PROTOCOL_VERSION, )) if sys.version_info[2:] != (2, 7): raise unittest.SkipTest( 'This test compares static strings generated from dict items, which may change orders. Test with 2.7.' ) cluster = Cluster(protocol_version=PROTOCOL_VERSION) session = cluster.connect() session.execute(""" CREATE KEYSPACE export_udts WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '1'} AND durable_writes = true; """) session.execute(""" CREATE TYPE export_udts.street ( street_number int, street_name text) """) session.execute(""" CREATE TYPE export_udts.zip ( zipcode int, zip_plus_4 int) """) session.execute(""" CREATE TYPE export_udts.address ( street_address frozen<street>, zip_code frozen<zip>) """) session.execute(""" CREATE TABLE export_udts.users ( user text PRIMARY KEY, addresses map<text, frozen<address>>) """) expected_string = """CREATE KEYSPACE export_udts WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '1'} AND durable_writes = true; CREATE TYPE export_udts.street ( street_number int, street_name text ); CREATE TYPE export_udts.zip ( zipcode int, zip_plus_4 int ); CREATE TYPE export_udts.address ( street_address frozen<street>, zip_code frozen<zip> ); CREATE TABLE export_udts.users ( user text PRIMARY KEY, addresses map<text, frozen<address>> ) WITH bloom_filter_fp_chance = 0.01 AND caching = '{"keys":"ALL", "rows_per_partition":"NONE"}' AND comment = '' AND compaction = {'min_threshold': '4', 'class': 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy', 'max_threshold': '32'} AND compression = {'sstable_compression': 'org.apache.cassandra.io.compress.LZ4Compressor'} AND dclocal_read_repair_chance = 0.1 AND default_time_to_live = 0 AND gc_grace_seconds = 864000 AND max_index_interval = 2048 AND memtable_flush_period_in_ms = 0 AND min_index_interval = 128 AND read_repair_chance = 0.0 AND speculative_retry = '99.0PERCENTILE';""" self.assert_equal_diff( cluster.metadata.keyspaces['export_udts'].export_as_string(), expected_string) table_meta = cluster.metadata.keyspaces['export_udts'].tables['users'] expected_string = """CREATE TABLE export_udts.users ( user text PRIMARY KEY, addresses map<text, frozen<address>> ) WITH bloom_filter_fp_chance = 0.01 AND caching = '{"keys":"ALL", "rows_per_partition":"NONE"}' AND comment = '' AND compaction = {'min_threshold': '4', 'class': 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy', 'max_threshold': '32'} AND compression = {'sstable_compression': 'org.apache.cassandra.io.compress.LZ4Compressor'} AND dclocal_read_repair_chance = 0.1 AND default_time_to_live = 0 AND gc_grace_seconds = 864000 AND max_index_interval = 2048 AND memtable_flush_period_in_ms = 0 AND min_index_interval = 128 AND read_repair_chance = 0.0 AND speculative_retry = '99.0PERCENTILE';""" self.assert_equal_diff(table_meta.export_as_string(), expected_string) cluster.shutdown()
def setUp(self): self.default_keyspace = models.DEFAULT_KEYSPACE cass_version = get_server_versions()[0] if cass_version < (3, 0): raise unittest.SkipTest("Materialized views require Cassandra 3.0+") super(TestNamedWithMV, self).setUp()
def test_legacy_tables(self): if get_server_versions()[0] < (2, 1, 0): raise unittest.SkipTest( 'Test schema output assumes 2.1.0+ options') if sys.version_info[2:] != (2, 7): raise unittest.SkipTest( 'This test compares static strings generated from dict items, which may change orders. Test with 2.7.' ) cli_script = """CREATE KEYSPACE legacy WITH placement_strategy = 'SimpleStrategy' AND strategy_options = {replication_factor:1}; USE legacy; CREATE COLUMN FAMILY simple_no_col WITH comparator = UTF8Type AND key_validation_class = UUIDType AND default_validation_class = UTF8Type; CREATE COLUMN FAMILY simple_with_col WITH comparator = UTF8Type and key_validation_class = UUIDType and default_validation_class = UTF8Type AND column_metadata = [ {column_name: col_with_meta, validation_class: UTF8Type} ]; CREATE COLUMN FAMILY composite_partition_no_col WITH comparator = UTF8Type AND key_validation_class = 'CompositeType(UUIDType,UTF8Type)' AND default_validation_class = UTF8Type; CREATE COLUMN FAMILY composite_partition_with_col WITH comparator = UTF8Type AND key_validation_class = 'CompositeType(UUIDType,UTF8Type)' AND default_validation_class = UTF8Type AND column_metadata = [ {column_name: col_with_meta, validation_class: UTF8Type} ]; CREATE COLUMN FAMILY nested_composite_key WITH comparator = UTF8Type and key_validation_class = 'CompositeType(CompositeType(UUIDType,UTF8Type), LongType)' and default_validation_class = UTF8Type AND column_metadata = [ {column_name: full_name, validation_class: UTF8Type} ]; create column family composite_comp_no_col with column_type = 'Standard' and comparator = 'DynamicCompositeType(t=>org.apache.cassandra.db.marshal.TimeUUIDType,s=>org.apache.cassandra.db.marshal.UTF8Type,b=>org.apache.cassandra.db.marshal.BytesType)' and default_validation_class = 'BytesType' and key_validation_class = 'BytesType' and read_repair_chance = 0.0 and dclocal_read_repair_chance = 0.1 and gc_grace = 864000 and min_compaction_threshold = 4 and max_compaction_threshold = 32 and compaction_strategy = 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy' and caching = 'KEYS_ONLY' and cells_per_row_to_cache = '0' and default_time_to_live = 0 and speculative_retry = 'NONE' and comment = 'Stores file meta data'; create column family composite_comp_with_col with column_type = 'Standard' and comparator = 'DynamicCompositeType(t=>org.apache.cassandra.db.marshal.TimeUUIDType,s=>org.apache.cassandra.db.marshal.UTF8Type,b=>org.apache.cassandra.db.marshal.BytesType)' and default_validation_class = 'BytesType' and key_validation_class = 'BytesType' and read_repair_chance = 0.0 and dclocal_read_repair_chance = 0.1 and gc_grace = 864000 and min_compaction_threshold = 4 and max_compaction_threshold = 32 and compaction_strategy = 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy' and caching = 'KEYS_ONLY' and cells_per_row_to_cache = '0' and default_time_to_live = 0 and speculative_retry = 'NONE' and comment = 'Stores file meta data' and column_metadata = [ {column_name : 'b@6d616d6d616a616d6d61', validation_class : BytesType, index_name : 'idx_one', index_type : 0}, {column_name : 'b@6869746d65776974686d75736963', validation_class : BytesType, index_name : 'idx_two', index_type : 0}] and compression_options = {'sstable_compression' : 'org.apache.cassandra.io.compress.LZ4Compressor'};""" # note: the inner key type for legacy.nested_composite_key # (org.apache.cassandra.db.marshal.CompositeType(org.apache.cassandra.db.marshal.UUIDType, org.apache.cassandra.db.marshal.UTF8Type)) # is a bit strange, but it replays in CQL with desired results expected_string = """CREATE KEYSPACE legacy WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '1'} AND durable_writes = true; /* Warning: Table legacy.composite_comp_with_col omitted because it has constructs not compatible with CQL (was created via legacy API). Approximate structure, for reference: (this should not be used to reproduce this schema) CREATE TABLE legacy.composite_comp_with_col ( key blob, t timeuuid, b blob, s text, "b@6869746d65776974686d75736963" blob, "b@6d616d6d616a616d6d61" blob, PRIMARY KEY (key, t, b, s) ) WITH COMPACT STORAGE AND CLUSTERING ORDER BY (t ASC, b ASC, s ASC) AND caching = '{"keys":"ALL", "rows_per_partition":"NONE"}' AND comment = 'Stores file meta data' AND compaction = {'min_threshold': '4', 'class': 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy', 'max_threshold': '32'} AND compression = {'sstable_compression': 'org.apache.cassandra.io.compress.LZ4Compressor'} AND dclocal_read_repair_chance = 0.1 AND default_time_to_live = 0 AND gc_grace_seconds = 864000 AND max_index_interval = 2048 AND memtable_flush_period_in_ms = 0 AND min_index_interval = 128 AND read_repair_chance = 0.0 AND speculative_retry = 'NONE'; CREATE INDEX idx_two ON legacy.composite_comp_with_col ("b@6869746d65776974686d75736963"); CREATE INDEX idx_one ON legacy.composite_comp_with_col ("b@6d616d6d616a616d6d61"); */ CREATE TABLE legacy.nested_composite_key ( key 'org.apache.cassandra.db.marshal.CompositeType(org.apache.cassandra.db.marshal.UUIDType, org.apache.cassandra.db.marshal.UTF8Type)', key2 bigint, full_name text, PRIMARY KEY ((key, key2)) ) WITH COMPACT STORAGE AND caching = '{"keys":"ALL", "rows_per_partition":"NONE"}' AND comment = '' AND compaction = {'min_threshold': '4', 'class': 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy', 'max_threshold': '32'} AND compression = {'sstable_compression': 'org.apache.cassandra.io.compress.LZ4Compressor'} AND dclocal_read_repair_chance = 0.1 AND default_time_to_live = 0 AND gc_grace_seconds = 864000 AND max_index_interval = 2048 AND memtable_flush_period_in_ms = 0 AND min_index_interval = 128 AND read_repair_chance = 0.0 AND speculative_retry = 'NONE'; CREATE TABLE legacy.composite_partition_with_col ( key uuid, key2 text, col_with_meta text, PRIMARY KEY ((key, key2)) ) WITH COMPACT STORAGE AND caching = '{"keys":"ALL", "rows_per_partition":"NONE"}' AND comment = '' AND compaction = {'min_threshold': '4', 'class': 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy', 'max_threshold': '32'} AND compression = {'sstable_compression': 'org.apache.cassandra.io.compress.LZ4Compressor'} AND dclocal_read_repair_chance = 0.1 AND default_time_to_live = 0 AND gc_grace_seconds = 864000 AND max_index_interval = 2048 AND memtable_flush_period_in_ms = 0 AND min_index_interval = 128 AND read_repair_chance = 0.0 AND speculative_retry = 'NONE'; CREATE TABLE legacy.composite_partition_no_col ( key uuid, key2 text, column1 text, value text, PRIMARY KEY ((key, key2), column1) ) WITH COMPACT STORAGE AND CLUSTERING ORDER BY (column1 ASC) AND caching = '{"keys":"ALL", "rows_per_partition":"NONE"}' AND comment = '' AND compaction = {'min_threshold': '4', 'class': 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy', 'max_threshold': '32'} AND compression = {'sstable_compression': 'org.apache.cassandra.io.compress.LZ4Compressor'} AND dclocal_read_repair_chance = 0.1 AND default_time_to_live = 0 AND gc_grace_seconds = 864000 AND max_index_interval = 2048 AND memtable_flush_period_in_ms = 0 AND min_index_interval = 128 AND read_repair_chance = 0.0 AND speculative_retry = 'NONE'; CREATE TABLE legacy.simple_with_col ( key uuid PRIMARY KEY, col_with_meta text ) WITH COMPACT STORAGE AND caching = '{"keys":"ALL", "rows_per_partition":"NONE"}' AND comment = '' AND compaction = {'min_threshold': '4', 'class': 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy', 'max_threshold': '32'} AND compression = {'sstable_compression': 'org.apache.cassandra.io.compress.LZ4Compressor'} AND dclocal_read_repair_chance = 0.1 AND default_time_to_live = 0 AND gc_grace_seconds = 864000 AND max_index_interval = 2048 AND memtable_flush_period_in_ms = 0 AND min_index_interval = 128 AND read_repair_chance = 0.0 AND speculative_retry = 'NONE'; CREATE TABLE legacy.simple_no_col ( key uuid, column1 text, value text, PRIMARY KEY (key, column1) ) WITH COMPACT STORAGE AND CLUSTERING ORDER BY (column1 ASC) AND caching = '{"keys":"ALL", "rows_per_partition":"NONE"}' AND comment = '' AND compaction = {'min_threshold': '4', 'class': 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy', 'max_threshold': '32'} AND compression = {'sstable_compression': 'org.apache.cassandra.io.compress.LZ4Compressor'} AND dclocal_read_repair_chance = 0.1 AND default_time_to_live = 0 AND gc_grace_seconds = 864000 AND max_index_interval = 2048 AND memtable_flush_period_in_ms = 0 AND min_index_interval = 128 AND read_repair_chance = 0.0 AND speculative_retry = 'NONE'; /* Warning: Table legacy.composite_comp_no_col omitted because it has constructs not compatible with CQL (was created via legacy API). Approximate structure, for reference: (this should not be used to reproduce this schema) CREATE TABLE legacy.composite_comp_no_col ( key blob, column1 'org.apache.cassandra.db.marshal.DynamicCompositeType(org.apache.cassandra.db.marshal.TimeUUIDType, org.apache.cassandra.db.marshal.BytesType, org.apache.cassandra.db.marshal.UTF8Type)', column2 text, value blob, PRIMARY KEY (key, column1, column1, column2) ) WITH COMPACT STORAGE AND CLUSTERING ORDER BY (column1 ASC, column1 ASC, column2 ASC) AND caching = '{"keys":"ALL", "rows_per_partition":"NONE"}' AND comment = 'Stores file meta data' AND compaction = {'min_threshold': '4', 'class': 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy', 'max_threshold': '32'} AND compression = {'sstable_compression': 'org.apache.cassandra.io.compress.LZ4Compressor'} AND dclocal_read_repair_chance = 0.1 AND default_time_to_live = 0 AND gc_grace_seconds = 864000 AND max_index_interval = 2048 AND memtable_flush_period_in_ms = 0 AND min_index_interval = 128 AND read_repair_chance = 0.0 AND speculative_retry = 'NONE'; */""" ccm = get_cluster() ccm.run_cli(cli_script) cluster = Cluster(protocol_version=PROTOCOL_VERSION) session = cluster.connect() legacy_meta = cluster.metadata.keyspaces['legacy'] self.assert_equal_diff(legacy_meta.export_as_string(), expected_string) session.execute('DROP KEYSPACE legacy') cluster.shutdown()
def test_export_keyspace_schema_udts(self): """ Test udt exports """ if get_server_versions()[0] < (2, 1, 0): raise unittest.SkipTest('UDTs were introduced in Cassandra 2.1') cluster = Cluster(protocol_version=PROTOCOL_VERSION) session = cluster.connect() session.execute(""" CREATE KEYSPACE export_udts WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '1'} AND durable_writes = true; """) session.execute(""" CREATE TYPE export_udts.street ( street_number int, street_name text) """) session.execute(""" CREATE TYPE export_udts.zip ( zipcode int, zip_plus_4 int) """) session.execute(""" CREATE TYPE export_udts.address ( street_address street, zip_code zip) """) session.execute(""" CREATE TABLE export_udts.users ( user text PRIMARY KEY, addresses map<text, address>) """) expected_string = """CREATE KEYSPACE export_udts WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '1'} AND durable_writes = true; CREATE TYPE export_udts.street ( street_number int, street_name text ); CREATE TYPE export_udts.zip ( zipcode int, zip_plus_4 int ); CREATE TYPE export_udts.address ( street_address street, zip_code zip ); CREATE TABLE export_udts.users ( user text PRIMARY KEY, addresses map<text, address> ) WITH bloom_filter_fp_chance = 0.01 AND caching = '{"keys":"ALL", "rows_per_partition":"NONE"}' AND comment = '' AND compaction = {'min_threshold': '4', 'class': 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy', 'max_threshold': '32'} AND compression = {'sstable_compression': 'org.apache.cassandra.io.compress.LZ4Compressor'} AND dclocal_read_repair_chance = 0.1 AND default_time_to_live = 0 AND gc_grace_seconds = 864000 AND max_index_interval = 2048 AND memtable_flush_period_in_ms = 0 AND min_index_interval = 128 AND read_repair_chance = 0.0 AND speculative_retry = '99.0PERCENTILE';""" self.assertEqual(cluster.metadata.keyspaces['export_udts'].export_as_string(), expected_string) table_meta = cluster.metadata.keyspaces['export_udts'].tables['users'] expected_string = """CREATE TABLE export_udts.users ( user text PRIMARY KEY, addresses map<text, address> ) WITH bloom_filter_fp_chance = 0.01 AND caching = '{"keys":"ALL", "rows_per_partition":"NONE"}' AND comment = '' AND compaction = {'min_threshold': '4', 'class': 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy', 'max_threshold': '32'} AND compression = {'sstable_compression': 'org.apache.cassandra.io.compress.LZ4Compressor'} AND dclocal_read_repair_chance = 0.1 AND default_time_to_live = 0 AND gc_grace_seconds = 864000 AND max_index_interval = 2048 AND memtable_flush_period_in_ms = 0 AND min_index_interval = 128 AND read_repair_chance = 0.0 AND speculative_retry = '99.0PERCENTILE';""" self.assertEqual(table_meta.export_as_string(), expected_string)
def setUpClass(cls): cls.cass_version = get_server_versions()