def test_insertion(self): inserted = SimpleTestModel.objects.create(field_1='foo', field_2='bar', field_3='raw') self.assertIsNotNone(inserted.pk) self.assertEqual('foo', inserted.field_1) self.assertEqual('bar', inserted.field_2) self.assertEqual('raw', inserted.field_3) cf_simple_model = get_column_family(self.connection, SimpleTestModel) result = cf_simple_model.objects.get(id=inserted.pk) self.assertEqual(result.pk, inserted.pk) self.assertEqual(result.field_1, inserted.field_1) self.assertEqual(result.field_2, inserted.field_2) self.assertEqual(result.field_3, inserted.field_3) pk = result.pk result.delete() try: should_not_exist = cf_simple_model.objects.get(id=pk) self.assertIsNone(should_not_exist) except cf_simple_model.DoesNotExist: pass
def test_insertion(self): inserted = SimpleTestModel.objects.create( field_1='foo', field_2='bar', field_3='raw' ) self.assertIsNotNone( inserted.pk ) self.assertEqual('foo', inserted.field_1) self.assertEqual('bar', inserted.field_2) self.assertEqual('raw', inserted.field_3) cf_simple_model = get_column_family( self.connection, SimpleTestModel ) result = cf_simple_model.objects.get(id=inserted.pk) self.assertEqual(result.pk, inserted.pk) self.assertEqual(result.field_1, inserted.field_1) self.assertEqual(result.field_2, inserted.field_2) self.assertEqual(result.field_3, inserted.field_3)
def _add_field( self, model, field, column_family=None ): if None is column_family: column_family = get_column_family( self.connection, model ) db_field = ( field.db_column if field.db_column else field.column ) cql_field_type = internal_type_to_column_map[field.get_internal_type()] cql_field = cql_field_type( primary_key=field.primary_key, index=field.db_index, db_field=db_field, required=not field.blank ) setattr(column_family, db_field, cql_field) column_family._columns[db_field] = cql_field CqlColumnFamilyMetaClass.update_column_family(column_family) return column_family
def alter_field( self, model, old_field, new_field, strict=False ): ''' A little more care needs to be taken here to handle cases where exceptions are raised in either _remove_field or in _add_field. This could leave the column_family registery dirty and in a state that would require the web service to restart to function properly. ''' column_family = get_column_family( self.connection, model ) self._remove_field( model, old_field, column_family=column_family ) self._add_field( model, new_field, column_family=column_family ) self._create_db_table(column_family)
def create_model( self, model ): self.connection.create_keyspace() column_family = get_column_family( self.connection, model ) self._create_db_table(column_family)
def delete_model( self, model ): column_family = get_column_family( self.connection, model ) db_management.drop_table(column_family)
def insert( self, values, return_id ): meta = self.query.get_meta() column_family = get_column_family( self.connection, self.query.model ) inserted_row_keys = [] with BatchQuery() as b: for row in values: if 'pk__token' in row: del row['pk__token'] if meta.has_auto_field and meta.pk.column not in row.keys(): if meta.pk.get_internal_type() == 'AutoField': ''' Using the default integer based AutoField is inefficient due to the fact that Cassandra has to count all the rows to determine the correct integer id. ''' row[meta.pk.column] = ( column_family.objects.all().count() + 1 ) elif hasattr(meta.pk, 'get_auto_value'): row[meta.pk.column] = meta.pk.get_auto_value() else: raise Exception( 'Please define a "get_auto_value" method ' 'on your custom AutoField that returns the ' 'next appropriate value for automatic primary ' 'key for your database model.' ) inserted = column_family.batch(b).create( **row ) inserted_row_keys.append(inserted.pk) if return_id: if len(inserted_row_keys) == 1: return inserted_row_keys[0] else: return inserted_row_keys
def add_field(self, model, field): column_family = get_column_family(self.connection, model) for key in column_family._columns.keys(): ''' Turn off indexing for old fields or sync_table will try to recreate them ''' if key is field.db_column: continue column_family._columns[key].index = False self._create_db_table(column_family)
def insert(self, values, return_id): meta = self.query.get_meta() column_family = get_column_family(self.connection, self.query.model) inserted_row_keys = [] with BatchQuery() as b: for row in values: if 'pk__token' in row: del row['pk__token'] if meta.has_auto_field and meta.pk.column not in row.keys(): if meta.pk.get_internal_type() == 'AutoField': ''' Using the default integer based AutoField is inefficient due to the fact that Cassandra has to count all the rows to determine the correct integer id. ''' row[meta.pk.column] = ( column_family.objects.all().count() + 1) elif hasattr(meta.pk, 'get_auto_value'): row[meta.pk.column] = meta.pk.get_auto_value() else: raise Exception( 'Please define a "get_auto_value" method ' 'on your custom AutoField that returns the ' 'next appropriate value for automatic primary ' 'key for your database model.') inserted = column_family.batch(b).create(**row) inserted_row_keys.append(inserted.pk) if return_id: if len(inserted_row_keys) == 1: return inserted_row_keys[0] else: return inserted_row_keys
def add_field( self, model, field ): column_family = get_column_family( self.connection, model ) for key in column_family._columns.keys(): ''' Turn off indexing for old fields or sync_table will try to recreate them ''' if key is field.db_column: continue column_family._columns[key].index = False self._create_db_table(column_family)
def _remove_field( self, model, field, column_family=None ): if None is column_family: column_family = get_column_family( self.connection, model ) delattr(column_family, field.name) db_field = ( field.db_column if field.db_column else field.column ) del column_family._columns[db_field] CqlColumnFamilyMetaClass.update_column_family(column_family) return column_family
def test_insertion(self): inserted = SimpleTestModel.objects.create( field_1='foo', field_2='bar', field_3='raw' ) self.assertIsNotNone( inserted.pk ) self.assertEqual('foo', inserted.field_1) self.assertEqual('bar', inserted.field_2) self.assertEqual('raw', inserted.field_3) cf_simple_model = get_column_family( self.connection, SimpleTestModel ) result = cf_simple_model.objects.get(id=inserted.pk) self.assertEqual(result.pk, inserted.pk) self.assertEqual(result.field_1, inserted.field_1) self.assertEqual(result.field_2, inserted.field_2) self.assertEqual(result.field_3, inserted.field_3) pk = result.pk result.delete() try: should_not_exist = cf_simple_model.objects.get( id=pk ) self.assertIsNone(should_not_exist) except cf_simple_model.DoesNotExist: pass
def sql_create_model( self, model, style, # Used for styling output known_models=set() ): self.connection.create_keyspace() meta = model._meta if ( not meta.managed or meta.proxy or meta.db_table in known_models ): return [], {} column_family = get_column_family( self.connection, model ) sync_table(column_family) return [], {}
def __init__( self, compiler, fields, allows_inefficient=None ): super(CassandraQuery, self).__init__( compiler, fields ) self.meta = self.query.get_meta() if hasattr(self.query.model, 'Cassandra'): self.cassandra_meta = self.query.model.Cassandra if ( None is allows_inefficient and hasattr(self.cassandra_meta, 'allow_inefficient_queries') ): self.allows_inefficient = ( self.cassandra_meta.allow_inefficient_queries ) else: self.cassandra_meta = None if None is allows_inefficient: if 'ALLOW_INEFFICIENT_QUERIES' in self.connection.settings_dict: self.allows_inefficient = self.connection.settings_dict[ 'ALLOW_INEFFICIENT_QUERIES' ] else: self.allows_inefficient = True # Default to True self.pk_column = ( self.meta.pk.db_column if self.meta.pk.db_column else self.meta.pk.column ) self.column_family = self.meta.db_table self.columns = [] model_fields = self.meta.fields for f in model_fields: if isinstance(f, TokenPartitionKeyField): continue self.columns.append(f) self.where = None self.limit = 100000000 self.timeout = None # TODO: Make this a config setting self.cache = None self.ordering = [] self.filters = [] self.inefficient_ordering = [] self.high_mark = None self.low_mark = None self.connection.ensure_connection() self.column_family_class = get_column_family( self.connection, self.query.model ) self.column_names = [ column.db_column if column.db_column else column.column for column in self.columns ] self.indexed_columns = [ column.db_column if column.db_column else column.column for column in self.columns if column.db_index ] self.partition_columns = [self.pk_column] if hasattr(self.cassandra_meta, 'partition_keys'): for key in self.cassandra_meta.partition_keys: field = self.meta.get_field(key) field_name = ( field.db_column if field.db_column else field.column ) if field_name not in self.partition_columns: self.partition_columns.append(field_name) self.clustering_columns = [] if hasattr(self.cassandra_meta, 'clustering_keys'): for key in self.cassandra_meta.clustering_keys: field = self.meta.get_field(key) self.clustering_columns.append( field.db_column if field.db_column else field.column ) self.cql_query = self.column_family_class.objects.values_list( *self.column_names ).allow_filtering()
def __init__( self, compiler, fields, allows_inefficient=True ): super(CassandraQuery, self).__init__( compiler, fields ) self.meta = self.query.get_meta() if hasattr(self.query.model, 'Cassandra'): self.cassandra_meta = self.query.model.Cassandra else: self.cassandra_meta = None self.pk_column = ( self.meta.pk.db_column if self.meta.pk.db_column else self.meta.pk.column ) self.column_family = self.meta.db_table self.columns = [] model_fields = self.meta.fields for f in model_fields: if isinstance(f, TokenPartitionKeyField): continue self.columns.append(f) self.where = None self.default_limit = 1000000 # TODO: Make this a config setting self.limit = self.default_limit self.timeout = None # TODO: Make this a config setting self.cache = None self.allows_inefficient = ( allows_inefficient # TODO: Make this a config setting ) self.ordering = [] self.filters = [] self.inefficient_ordering = [] self.high_mark = None self.low_mark = None self.connection.ensure_connection() self.column_family_class = get_column_family( self.connection, self.query.model ) self.column_names = [ column.db_column if column.db_column else column.column for column in self.columns ] self.indexed_columns = [ column.db_column if column.db_column else column.column for column in self.columns if column.db_index ] if hasattr(self.cassandra_meta, 'clustering_keys'): self.clustering_columns = ( self.cassandra_meta.clustering_keys ) else: self.clustering_columns = [] if hasattr(self.cassandra_meta, 'partition_keys'): self.partiton_columns = ( self.cassandra_meta.partition_keys ) else: self.partition_columns = [self.pk_column] self.cql_query = self.column_family_class.objects.values_list( *self.column_names ).allow_filtering()
def __init__(self, compiler, fields, allows_inefficient=None): super(CassandraQuery, self).__init__(compiler, fields) self.meta = self.query.get_meta() if hasattr(self.query.model, 'Cassandra'): self.cassandra_meta = self.query.model.Cassandra if (None is allows_inefficient and hasattr( self.cassandra_meta, 'allow_inefficient_queries')): self.allows_inefficient = ( self.cassandra_meta.allow_inefficient_queries) else: self.cassandra_meta = None if None is allows_inefficient: if 'ALLOW_INEFFICIENT_QUERIES' in self.connection.settings_dict: self.allows_inefficient = self.connection.settings_dict[ 'ALLOW_INEFFICIENT_QUERIES'] else: self.allows_inefficient = True # Default to True self.pk_column = (self.meta.pk.db_column if self.meta.pk.db_column else self.meta.pk.column) self.column_family = self.meta.db_table self.columns = [] model_fields = self.meta.fields for f in model_fields: if isinstance(f, TokenPartitionKeyField): continue self.columns.append(f) self.where = None self.limit = 100000000 self.timeout = None # TODO: Make this a config setting self.cache = None self.ordering = [] self.filters = [] self.inefficient_ordering = [] self.high_mark = None self.low_mark = None self.connection.ensure_connection() self.column_family_class = get_column_family(self.connection, self.query.model) self.column_names = [ column.db_column if column.db_column else column.column for column in self.columns ] self.indexed_columns = [ column.db_column if column.db_column else column.column for column in self.columns if column.db_index ] self.partition_columns = [self.pk_column] if hasattr(self.cassandra_meta, 'partition_keys'): for key in self.cassandra_meta.partition_keys: field = self.meta.get_field(key) field_name = (field.db_column if field.db_column else field.column) if field_name not in self.partition_columns: self.partition_columns.append(field_name) self.clustering_columns = [] if hasattr(self.cassandra_meta, 'clustering_keys'): for key in self.cassandra_meta.clustering_keys: field = self.meta.get_field(key) self.clustering_columns.append( field.db_column if field.db_column else field.column) self.cql_query = self.column_family_class.objects.values_list( *self.column_names).allow_filtering()
def create_model(self, model): self.connection.create_keyspace() column_family = get_column_family(self.connection, model) self._create_db_table(column_family)
def delete_model(self, model): column_family = get_column_family(self.connection, model) db_management.drop_table(column_family)