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