def test_create_drop_succeeeds(self): cluster = get_cluster() keyspace_ss = 'test_ks_ss' self.assertFalse(keyspace_ss in cluster.metadata.keyspaces) management.create_keyspace_simple(keyspace_ss, 2) self.assertTrue(keyspace_ss in cluster.metadata.keyspaces) management.drop_keyspace(keyspace_ss) self.assertFalse(keyspace_ss in cluster.metadata.keyspaces) with warnings.catch_warnings(record=True) as w: management.create_keyspace(keyspace_ss, strategy_class="SimpleStrategy", replication_factor=1) self.assertEqual(len(w), 1) self.assertEqual(w[-1].category, DeprecationWarning) self.assertTrue(keyspace_ss in cluster.metadata.keyspaces) management.drop_keyspace(keyspace_ss) self.assertFalse(keyspace_ss in cluster.metadata.keyspaces) keyspace_nts = 'test_ks_nts' self.assertFalse(keyspace_nts in cluster.metadata.keyspaces) management.create_keyspace_simple(keyspace_nts, 2) self.assertTrue(keyspace_nts in cluster.metadata.keyspaces) with warnings.catch_warnings(record=True) as w: management.delete_keyspace(keyspace_nts) self.assertEqual(len(w), 1) self.assertEqual(w[-1].category, DeprecationWarning) self.assertFalse(keyspace_nts in cluster.metadata.keyspaces)
def create_keyspace( self, keyspace, session=None ): settings = self.settings_dict keyspace_default_settings = { 'durable_writes': True, 'strategy_class': SimpleStrategy.name, 'replication_factor': 3 } keyspace_settings = settings.get( 'KEYSPACES', {} ).get( keyspace, {} ) keyspace_default_settings.update(keyspace_settings) keyspace_settings = keyspace_default_settings self.ensure_connection() create_keyspace( keyspace, **keyspace_settings )
def sync_cassandra(): from cassandra.cqlengine.management import sync_table, create_keyspace from benchmark.feeds import UserFeed, TimelineFeed create_keyspace('stream_framework_bench', 'SimpleStrategy', 3) for feed_class in [UserFeed, TimelineFeed]: timeline = feed_class.get_timeline_storage() sync_table(timeline.model)
def cassandra_setup(): from cassandra.cqlengine.management import create_table, create_keyspace aggregated_timeline = AggregatedFeed.get_timeline_storage() timeline = FashiolistaFeed.get_timeline_storage() user_timeline = UserFeed.get_timeline_storage() create_keyspace('test') create_table(aggregated_timeline.model) create_table(timeline.model) create_table(user_timeline.model)
def get_column_family( connection, model ): connection_settings = connection.settings_dict if hasattr(model, 'Cassandra'): cassandra_settings = model.Cassandra.__dict__ else: cassandra_settings = default_cassandra_model_settings if hasattr(cassandra_settings, 'keyspace'): keyspace = cassandra_settings.keyspace else: keyspace = connection_settings.get('DEFAULT_KEYSPACE') keyspace_settings = connection_settings.get('KEYSPACES', {}).get(keyspace) if None is keyspace_settings: keyspace_settings = {} # Replace with default keyspace settings. replication_factor = keyspace_settings.get( 'replication_factor', ) replication_strategy_class = keyspace_settings['strategy_class'] create_keyspace( keyspace, replication_strategy_class, replication_factor ) table_options = default_table_options if hasattr(cassandra_settings, 'table_options'): if not isinstance(cassandra_settings.table_optoins, dict): raise DatabaseError( 'The value of table_optoins in the Cassandra class ' 'must be a dict containing overrides for the default' 'column family options.' ) table_options.update(cassandra_settings.table_metadata) return type( str(model._meta.db_table), (CqlColumnFamily,), { '__model__': model, 'table_options': table_options } )
def setup(self, collection): """ :param collection: :return: """ connection.setup([CASSANDRA_1], collection) management.create_keyspace( collection, replication_factor=1, strategy_class='SimpleStrategy', ) TestModel.__keyspace__ = collection management.sync_table(TestModel)
def setup(self, force=False, throw=False): if self._setup and not force: return True try: connection.setup(self.uri, self.keyspace) management.create_keyspace(self.keyspace, replication_factor=1, strategy_class='SimpleStrategy') for model in self._models: model.__keyspace__ = self.keyspace management.sync_table(model) except NoHostAvailable: logger.error('Could not connect to Cassandra, expect errors.') return False # Note: return values are for test skipping self._setup = True return True
def setUp(self): class MyModel(Model): id = columns.Text(max_length=63, primary_key=True, default=lambda: str(uuid.uuid4())) value = columns.Text(max_length=63) self.model = MyModel connection.setup(['127.0.0.1'], self.keyspace) create_keyspace(self.keyspace, strategy_class='SimpleStrategy', replication_factor=1) sync_table(MyModel) class MyManager(CQLManager): model = self.model fields = ( 'id', 'value', ) create_fields = ('value', ) update_fields = ('value', ) self.manager_class = MyManager
def connect(): setup(["127.0.0.1"], "videos") management.create_keyspace('videos', 'SimpleStrategy',replication_factor=1)
from sys import path path.append(".") from cassandra.cqlengine.management import sync_table, create_keyspace from killranalytics.models import connect_cassandra, PageViews, RealTimeData connect_cassandra() ks = 'killranalytics' create_keyspace(ks, "SimpleStrategy", 1) sync_table(PageViews) sync_table(RealTimeData) print "done"
import uuid from cassandra.cqlengine import columns from cassandra.cqlengine import connection from datetime import datetime from cassandra.cqlengine.management import sync_table, create_keyspace from cassandra.cqlengine.models import Model ##Configuration-------- keyspace="octalspace" connection.default() create_keyspace(keyspace, replication_factor=1, strategy_class="SimpleStrategy") connection.setup(['127.0.0.1'], keyspace, protocol_version=3) ##/Configuration------- class Account(Model): pk = columns.UUID(primary_key=True) created_at = columns.DateTime() username = columns.Text() ''' So, how do you do tree data models in cassandra? It is a mystery My initial thought is that the top level post object, (a self post or a link) has a list of *all* it's children. That way we can do a batch read and get an entire page. Well mostly, one for the object, and once for all of it's descendents That use case is going to be the vast majority of our data stuff, getting a top level post and *all* descendents. For displaying it as a tree, we'd need to have each comment contain a list (well, unordered set) of it's immediate children.
def connect(): setup(["127.0.0.1"], "videos") management.create_keyspace('videos', 'SimpleStrategy', replication_factor=1)