Delete one or more hash fields.
331636
function hdel(key /* field-1, field-N, req */) {
  var args = slice.call(arguments, 1)
    , req = typeof args[args.length - 1] === 'object'
        ? args.pop() : null
    , val = this.getKey(key, req)
    , deleted = 0
    , i;

  // nothing at key
  if(!val) return 0;

  for(i = 0;i < args.length;i++) {
    deleted += val.delKey(args[i]);
  }

  if(val.hlen() === 0) {
    this.delKey(key, req);
  }

  return deleted;
}
1315658
public function removeOrphans(): void
    {
        $hashes = $this->findOrphanedHashes();
        if (count($hashes) > 0) {
            $this->removeHashes($hashes);
        }
    }
1163087
def delete(*keys, **connection_args):
    '''
    
    '''
    # Get connection args from keywords if set
    conn_args = {}
    for arg in ['host', 'port', 'db', 'password']:
        if arg in connection_args:
            conn_args[arg] = connection_args[arg]

    server = _connect(**conn_args)
    return server.delete(*keys)
239430
def clear(self):
        """"""    
        self.sam |= KEY_WRITE
        for v in list(self.values()):
            del self[v.name]
        for k in list(self.subkeys()):
            self.del_subkey(k.name)
469761
def unset_fields(self, fields):
        

        self.mongokat_collection.update_one({"_id": self["_id"]}, {"$unset": {
            f: 1 for f in fields
        }})

        for f in fields:
            if f in self:
                del self[f]
860196
def clear(self):
        """"""
        for k in list(self.keys()):
            if k not in self.extrakeys:
                del self[k]
1282400
def _delete(self, c, context, hm):
        """"""
        pools = hm.get("pools", [])

        for pool in pools:
            pool_id = pool.get("pool_id")
            self._dissociate(c, context, hm, pool_id)

        self._delete_unused(c, context, hm)
661245
def destroy_keys attribute, *keys
      for key in keys
        new_value = send(attribute)
        new_value.delete(key.to_s)
        send("#{attribute}=", new_value)
      end
      self
    end
918279
def delete_all(self): 
        
        for record in self.find(using_name=False, data_only=True):
            res = self.delete_one(record["id"])
825385
public static void clear() {
        lock.writeLock().lock();
        try {
            allStrings = new EfficientStringBiMap(HASH_MODULO);
            indexCounter.set(0);
        } finally {
            lock.writeLock().unlock();
        }
    }
700202
def delete(self, hdfs_path, recursive=False):
        """"""
        return self.client.delete(hdfs_path, recursive=recursive)
359358
def clear(self):
        
        self.__modified_data__ = {}
        self.__deleted_fields__ = [field for field in self.__original_data__.keys()]
865648
public void clear() {
		this.hashSize = this.startHashSize;
		this.numTables = this.startNumTables;
		this.numElements = 0;

		this.hashfunctions.clear();
		this.tables.clear();
		int sizeTables = 1 << this.startHashSize;
		for (int i = 0; i < this.startNumTables; i++) {
			this.hashfunctions.add(new DietzfelbingerHash(this.startHashSize,
					this.random));
			List<Entry<T>> table = new ArrayList<Entry<T>>(sizeTables);
			for (int j = 0; j < sizeTables; j++) {
				table.add(null);
			}
			this.tables.add(table);
		}

		this.stash.clear();
		this.stashSize = 0;
	}
163603
def _clean_fields(allowed_fields: dict, fields: FieldsParam) -> Iterable[str]:
    """"""
    if fields == ALL:
        fields = allowed_fields.keys()
    else:
        fields = tuple(fields)
        unknown_fields = set(fields) - allowed_fields.keys()
        if unknown_fields:
            raise ValueError('Unknown fields: {}'.format(unknown_fields))
    return fields
392390
protected function cleanUp()
    {
        $files = glob(__DIR__.DIRECTORY_SEPARATOR.'Mapping'.DIRECTORY_SEPARATOR.'{DataType,Property,Type}'.DIRECTORY_SEPARATOR.'*.php', GLOB_BRACE);
        foreach ($files as $file) {
            unlink($file);
        }
    }
894508
def strip_hashes(s)
		s = s[num_leading_hashes(s), s.size]
		i = s.size-1
		while i > 0 && (s[i,1] =~ /(#|\s)/); i-=1; end
		s[0, i+1].strip
	end
177297
def delete(type, hash)
      raise Dis::Errors::ReadOnlyError if readonly?
      delete!(type, hash)
    end