def _check_partition_value_generation(self, model, state, reverse=False):
"""
This generates a some statements based on the partition_key_index of the model.
It then validates that order of the partition key values in the statement matches the index
specified in the models partition_key_index
"""
# Setup some unique values for statement generation
uuid = uuid4()
values = {
"k": 5,
"v": 3,
"partition": uuid,
"cluster": 6,
"count": 42,
"text": "text",
"float": 3.1415,
"text_2": "text_2",
}
res = dict((v, k) for k, v in values.items())
items = list(model._partition_key_index.items())
if reverse:
items.reverse()
# Add where clauses for each partition key
for partition_key, position in items:
wc = WhereClause(partition_key, EqualsOperator(),
values.get(partition_key))
state._add_where_clause(wc)
# Iterate over the partition key values check to see that their index matches
# Those specified in the models partition field
for indx, value in enumerate(
state.partition_key_values(model._partition_key_index)):
name = res.get(value)
self.assertEqual(indx, model._partition_key_index.get(name))
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 set_delete_null_columns(self, conditionals=None):
"""Set self.cleanup_statement to delete query to remove columns that
have changed to null.
"""
ds = DeleteStatement(
self.column_family_name, conditionals=conditionals, if_exists=self._if_exists
)
deleted_fields = False
static_only = True
for _, v in self.instance._values.items():
col = v.column
if v.deleted:
ds.add_field(col.db_field_name)
deleted_fields = True
static_only &= col.static
elif isinstance(col, columns.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
static_only |= col.static
if deleted_fields:
keys = self.model._partition_keys if static_only else self.model._primary_keys
for name, col in keys.items():
ds.add_where(col, EqualsOperator(), getattr(self.instance, name))
self.cleanup_statement = ds
def prepare(self):
if self.instance is None:
raise CQLEngineException("DML Query intance attribute is None")
assert type(self.instance) == self.model
null_clustering_key = False if len(self.instance._clustering_keys) == 0 else True
static_changed_only = True
statement = UpdateStatement(
self.column_family_name,
ttl=self._ttl,
timestamp=self._timestamp,
conditionals=self._conditional,
if_exists=self._if_exists,
)
for name, col in self.instance._clustering_keys.items():
null_clustering_key = null_clustering_key and col._val_is_null(
getattr(self.instance, name, None)
)
updated_columns = set()
# get defined fields and their column names
for name, col in self.model._columns.items():
# if clustering key is null, don't include non static columns
if null_clustering_key and not col.static and not col.partition_key:
continue
if not col.is_primary_key:
val = getattr(self.instance, name, None)
val_mgr = self.instance._values[name]
if val is None:
continue
if not val_mgr.changed and not isinstance(col, columns.Counter):
continue
static_changed_only = static_changed_only and col.static
statement.add_update(col, val, previous=val_mgr.previous_value)
updated_columns.add(col.db_field_name)
if not null_clustering_key:
# remove conditions on fields that have been updated
delete_conditionals = (
[
condition
for condition in self._conditional
if condition.field not in updated_columns
]
if self._conditional
else None
)
self.set_delete_null_columns(delete_conditionals)
if statement.assignments:
for name, col in self.model._primary_keys.items():
# only include clustering key if clustering key is not null, and non static columns are changed to avoid cql error
if (null_clustering_key or static_changed_only) and (not col.partition_key):
continue
statement.add_where(col, EqualsOperator(), getattr(self.instance, name))
self.statement = statement
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": columns.DateTime().to_database(now)})
def prepare(self):
if self.instance is None:
raise CQLEngineException("DML Query instance attribute is None")
ds = DeleteStatement(
self.column_family_name,
timestamp=self._timestamp,
conditionals=self._conditional,
if_exists=self._if_exists,
)
for name, col in self.model._primary_keys.items():
val = getattr(self.instance, name)
if val is None and not col.partition_key:
continue
ds.add_where(col, EqualsOperator(), val)
self.statement = 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