code: def zadd(self, name, mapping, nx=False, xx=False, ch=False, incr=False):
          
          if not mapping:
              raise DataError("ZADD requires at least one element/score pair")
          if nx and xx:
              raise DataError("ZADD allows either 'nx' or 'xx', not both")
          if incr and len(mapping) != 1:
              raise DataError("ZADD option 'incr' only works when passing a "
                              "single element/score pair")
          pieces = []
          options = {}
          if nx:
              pieces.append(Token.get_token('NX'))
          if xx:
              pieces.append(Token.get_token('XX'))
          if ch:
              pieces.append(Token.get_token('CH'))
          if incr:
              pieces.append(Token.get_token('INCR'))
              options['as_score'] = True
          for pair in iteritems(mapping):
              pieces.append(pair[1])
              pieces.append(pair[0])
          return self.execute_command('ZADD', name, *pieces, **options)
docs: Set any number of element-name, score pairs to the key ``name``. Pairs
          are specified as a dict of element-names keys to score values.
  
          ``nx`` forces ZADD to only create new elements and not to update
          scores for elements that already exist.
  
          ``xx`` forces ZADD to only update scores of elements that already
          exist. New elements will not be added.
  
          ``ch`` modifies the return value to be the numbers of elements changed.
          Changed elements include new elements that were added and elements
          whose scores changed.
  
          ``incr`` modifies ZADD to behave like ZINCRBY. In this mode only a
          single element/score pair can be specified and the score is the amount
          the existing score will be incremented by. When using this mode the
          return value of ZADD will be the new score of the element.
  
          The return value of ZADD varies based on the mode specified. With no
          options, ZADD returns the number of new elements added to the sorted
          set.