def test_where_clause_rendering(self):
""" tests that where clauses are rendered properly """
wc = WhereClause('a', EqualsOperator(), 'c')
wc.set_context_id(5)
self.assertEqual('"a" = %(5)s', six.text_type(wc), six.text_type(wc))
self.assertEqual('"a" = %(5)s', str(wc), type(wc))
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):
"""
updates a row.
This is a blind update call.
All validation and cleaning needs to happen
prior to calling this.
"""
if self.instance is None:
raise CQLEngineException("DML Query intance attribute is None")
assert type(self.instance) == self.model
static_update_only = True
statement = UpdateStatement(self.column_family_name, ttl=self._ttl,
timestamp=self._timestamp, transactions=self._transaction)
#get defined fields and their column names
for name, col in self.model._columns.items():
if not col.is_primary_key:
val = getattr(self.instance, name, None)
val_mgr = self.instance._values[name]
# don't update something that is null
if val is None:
continue
# don't update something if it hasn't changed
if not val_mgr.changed and not isinstance(col, Counter):
continue
static_update_only = (static_update_only and col.static)
if isinstance(col, (BaseContainerColumn, Counter)):
# get appropriate clause
if isinstance(col, List): klass = ListUpdateClause
elif isinstance(col, Map): klass = MapUpdateClause
elif isinstance(col, Set): klass = SetUpdateClause
elif isinstance(col, Counter): klass = CounterUpdateClause
else: raise RuntimeError
# do the stuff
clause = klass(col.db_field_name, val,
previous=val_mgr.previous_value, column=col)
if clause.get_context_size() > 0:
statement.add_assignment_clause(clause)
else:
statement.add_assignment_clause(AssignmentClause(
col.db_field_name,
col.to_database(val)
))
if statement.get_context_size() > 0 or self.instance._has_counter:
for name, col in self.model._primary_keys.items():
if static_update_only and (not col.partition_key):
continue
statement.add_where_clause(WhereClause(
col.db_field_name,
EqualsOperator(),
col.to_database(getattr(self.instance, name))
))
self._execute(statement)
self._delete_null_columns()
def test_mintimeuuid_function(self):
"""
Tests that queries with helper functions are generated properly
"""
now = datetime.now()
where = WhereClause('time', EqualsOperator(), functions.MinTimeUUID(now))
where.set_context_id(5)
self.assertEqual(str(where), '"time" = MinTimeUUID(%(5)s)')
ctx = {}
where.update_context(ctx)
self.assertEqual(ctx, {'5': DateTime().to_database(now)})
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_equality_method(self):
""" tests that 2 identical where clauses evaluate as == """
wc1 = WhereClause('a', EqualsOperator(), 'c')
wc2 = WhereClause('a', EqualsOperator(), 'c')
assert wc1 == wc2
def __eq__(self, other):
return WhereClause(six.text_type(self), EqualsOperator(), self._to_database(other))