def delete(self):
""" Deletes one instance """
if self.instance is None:
raise CQLEngineException("DML Query instance attribute is None")
ds = DeleteStatement(self.column_family_name)
for name, col in self.model._primary_keys.items():
ds.add_where_clause(
WhereClause(col.db_field_name, EqualsOperator(), col.to_database(getattr(self.instance, name)))
)
self._execute(ds)
def delete(self):
""" Deletes one instance """
if self.instance is None:
raise CQLEngineException("DML Query instance attribute is None")
ds = DeleteStatement(self.column_family_name,
timestamp=self._timestamp)
for name, col in self.model._primary_keys.items():
ds.add_where_clause(
WhereClause(col.db_field_name, EqualsOperator(),
col.to_database(getattr(self.instance, name))))
self._execute(ds)
def test_context_update(self):
ds = DeleteStatement('table', None)
ds.add_field(MapDeleteClause('d', {1: 2}, {1: 2, 3: 4}))
ds.add_where_clause(WhereClause('a', EqualsOperator(), 'b'))
ds.update_context_id(7)
self.assertEqual(six.text_type(ds),
'DELETE "d"[%(8)s] FROM table WHERE "a" = %(7)s')
self.assertEqual(ds.get_context(), {'7': 'b', '8': 3})
def _delete_null_columns(self):
"""
executes a delete query to remove columns that have changed to null
"""
ds = DeleteStatement(self.column_family_name)
deleted_fields = False
for _, v in self.instance._values.items():
col = v.column
if v.deleted:
ds.add_field(col.db_field_name)
deleted_fields = True
elif isinstance(col, Map):
uc = MapDeleteClause(col.db_field_name, v.value, v.previous_value)
if uc.get_context_size() > 0:
ds.add_field(uc)
deleted_fields = True
if deleted_fields:
for name, col in self.model._primary_keys.items():
ds.add_where_clause(WhereClause(
col.db_field_name,
EqualsOperator(),
col.to_database(getattr(self.instance, name))
))
self._execute(ds)
def test_context_update(self):
ds = DeleteStatement('table', None)
ds.add_field(MapDeleteClause('d', {1: 2}, {1:2, 3: 4}))
ds.add_where_clause(WhereClause('a', EqualsOperator(), 'b'))
ds.update_context_id(7)
self.assertEqual(unicode(ds), 'DELETE "d"[:8] FROM table WHERE "a" = :7')
self.assertEqual(ds.get_context(), {'7': 'b', '8': 3})
def test_field_rendering(self):
""" tests that fields are properly added to the select statement """
ds = DeleteStatement('table', ['f1', 'f2'])
self.assertTrue(
six.text_type(ds).startswith('DELETE "f1", "f2"'),
six.text_type(ds))
self.assertTrue(str(ds).startswith('DELETE "f1", "f2"'), str(ds))
def _delete_null_columns(self):
"""
executes a delete query to remove columns that have changed to null
"""
ds = DeleteStatement(self.column_family_name)
deleted_fields = False
for _, v in self.instance._values.items():
col = v.column
if v.deleted:
ds.add_field(col.db_field_name)
deleted_fields = True
elif isinstance(col, Map):
uc = MapDeleteClause(col.db_field_name, v.value, v.previous_value)
if uc.get_context_size() > 0:
ds.add_field(uc)
deleted_fields = True
if deleted_fields:
for name, col in self.model._primary_keys.items():
ds.add_where_clause(WhereClause(
col.db_field_name,
EqualsOperator(),
col.to_database(getattr(self.instance, name))
))
self._execute(ds)
def update(self, **values):
""" Updates the rows in this queryset """
if not values:
return
nulled_columns = set()
us = UpdateStatement(self.column_family_name,
where=self._where,
ttl=self._ttl,
timestamp=self._timestamp)
for name, val in values.items():
col_name, col_op = self._parse_filter_arg(name)
col = self.model._columns.get(col_name)
# check for nonexistant columns
if col is None:
raise ValidationError("{}.{} has no column named: {}".format(
self.__module__, self.model.__name__, col_name))
# check for primary key update attempts
if col.is_primary_key:
raise ValidationError(
"Cannot apply update to primary key '{}' for {}.{}".format(
col_name, self.__module__, self.model.__name__))
val = col.validate(val)
if val is None:
nulled_columns.add(col_name)
continue
# add the update statements
if isinstance(col, Counter):
# TODO: implement counter updates
raise NotImplementedError
elif isinstance(col, (List, Set, Map)):
if isinstance(col, List):
klass = ListUpdateClause
elif isinstance(col, Set):
klass = SetUpdateClause
elif isinstance(col, Map):
klass = MapUpdateClause
else:
raise RuntimeError
us.add_assignment_clause(
klass(col_name, col.to_database(val), operation=col_op))
else:
us.add_assignment_clause(
AssignmentClause(col_name, col.to_database(val)))
if us.assignments:
self._execute(us)
if nulled_columns:
ds = DeleteStatement(self.column_family_name,
fields=nulled_columns,
where=self._where)
self._execute(ds)
def delete(self):
"""
Deletes the contents of a query
"""
#validate where clause
partition_key = [x for x in self.model._primary_keys.values()][0]
if not any([c.field == partition_key.column_name for c in self._where]):
raise QueryException("The partition key must be defined on delete queries")
dq = DeleteStatement(
self.column_family_name,
where=self._where,
timestamp=self._timestamp
)
self._execute(dq)
def test_table_rendering(self):
ds = DeleteStatement('table', None)
self.assertTrue(
six.text_type(ds).startswith('DELETE FROM table'),
six.text_type(ds))
self.assertTrue(str(ds).startswith('DELETE FROM table'), str(ds))
def test_context(self):
ds = DeleteStatement('table', None)
ds.add_where_clause(WhereClause('a', EqualsOperator(), 'b'))
self.assertEqual(ds.get_context(), {'0': 'b'})
def test_where_clause_rendering(self):
ds = DeleteStatement('table', None)
ds.add_where_clause(WhereClause('a', EqualsOperator(), 'b'))
self.assertEqual(six.text_type(ds),
'DELETE FROM table WHERE "a" = %(0)s',
six.text_type(ds))
def test_where_clause_rendering(self):
ds = DeleteStatement('table', None)
ds.add_where_clause(WhereClause('a', EqualsOperator(), 'b'))
self.assertEqual(unicode(ds), 'DELETE FROM table WHERE "a" = :0', unicode(ds))
def test_context(self):
ds = DeleteStatement('table', None)
ds.add_where_clause(WhereClause('a', EqualsOperator(), 'b'))
self.assertEqual(ds.get_context(), {'0': 'b'})
def test_none_fields_rendering(self):
""" tests that a '*' is added if no fields are passed in """
ds = DeleteStatement('table', None)
self.assertTrue(
six.text_type(ds).startswith('DELETE FROM'), six.text_type(ds))
self.assertTrue(str(ds).startswith('DELETE FROM'), str(ds))
def test_where_clause_rendering(self):
ds = DeleteStatement('table', None)
ds.add_where_clause(WhereClause('a', EqualsOperator(), 'b'))
self.assertEqual(six.text_type(ds), 'DELETE FROM table WHERE "a" = %(0)s', six.text_type(ds))
def test_single_field_is_listified(self):
""" tests that passing a string field into the constructor puts it into a list """
ds = DeleteStatement('table', 'field')
self.assertEqual(len(ds.fields), 1)
self.assertEqual(ds.fields[0].field, 'field')
