docs: 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
          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, transactions=self._transaction)
          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))
          #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]
  
                  # 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_changed_only = static_changed_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():
                  # 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_clause(WhereClause(
                      col.db_field_name,
                      EqualsOperator(),
                      col.to_database(getattr(self.instance, name))
                  ))
              self._execute(statement)
  
          if not null_clustering_key:
              self._delete_null_columns()