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)
