Deletes entry from memcache/apc DB.

@param string $key Cache key name

@param boolean True on success, False on failure
545124
private function delete_record($key)
    {
        if ($this->type == 'memcache') {
            // #1488592: use 2nd argument
            $result = $this->db->delete($key, 0);
        }
        else {
            $result = apc_delete($key);
        }

        if ($this->debug) {
            $this->debug('delete', $key, null, $result);
        }

        return $result;
    }
306821
protected function deleteValue($key)
    {
        $this->db->createCommand()
            ->delete($this->cacheTable, ['id' => $key])
            ->execute();

        return true;
    }
1041303
public function delete($key)
    {
        if (empty($this->memcache)) {
            return false;
        }

        $key = $this->processKey($key);

        return $this->memcache->delete($key);
    }
364658
public function delete($key)
    {
        $key = $this->_key($key);

        return $this->_Memcached->delete($key);
    }
586038
public static function clear($key)
    {
        $that = new static($key);

        if ($that->isCached()) {

            $deletionSuccess = unlink($that->filePath());
            
            if(!$deletionSuccess) {
                throw new CacheException(sprintf("Could not delete file '%s'", $this->filePath()));
            }
        }
    }
1295908
public function delete($key)
    {
        $query = sprintf('DELETE FROM `%s` WHERE `key` = :key', $this->table);
        $stmt = $this->pdo->prepare($query);

        return $stmt->execute(array(
            ':'.ConstProviderInterface::CACHE_PARAM_KEY => $key,
        ));
    }
128044
public function resetCache($key)
    {
        if ($this->sqlInitialized()) {
            $_key = $this->sql->real_escape_string($key);
            if ($this->sql->query("
                DELETE
                    FROM `{$this->table}`
                    WHERE
                        `{$this->key}` = '$_key'
            ")) {
                return true;
            }
            return false;
        }
    }
156278
public function delete($key)
    {
        $this->throwInvalidStringArgumentException($key);

        if($this->has($key)) {
            unset($this->cache[$key]);
            return true;
        }
        return false;
    }
1026338
public function deleteItem($key)
    {
        $this->validateKey($key);

        if ($this->hasItem($key)) {
            unset($this->data[$key]);
        }

        return true;
    }
932647
public function deleteItem($key)
    {
        if (!is_string($key))
            throw new InvalidArgumentException("Invalid key: " . WF::str($key)); 

        unset($this->cache[$key]);
        return true;
    }
860114
public function delete(string $key): bool
    {
        $file = $this->cacheFile($key);

        if (is_file($file)) {
            return unlink($file);
        }

        return false;
    }
668313
public function delete($key) {
    // Sending of a key of 'null' or an unset value is a failure.
    if (is_null($key)) {
      return false;
    }

    $request = new MemcacheDeleteRequest();
    $response = new MemcacheDeleteResponse();

    $request->addItem()->setKey($key);

    try {
      ApiProxy::makeSyncCall('memcache', 'Delete', $request, $response);
    } catch (Error $e) {
      return false;
    }
    $status_list = $response->getDeleteStatusList();
    return $status_list[0] == DeleteStatusCode::DELETED;
  }
1000012
public function remove($key)
	{
		$this->connect();

		$this->driver->delete($key);

		$rc = $this->driver->getResultCode();

		if ($rc !== \Memcached::RES_SUCCESS)
		{
			return false;
		}

		return true;
	}
669096
public function destroy(string $key): void
    {
        $key = $this->getKey($key);

        cache()->forget($key);
    }
1132672
public function delete($key)
    {

        $deleted = false;

        $catalog = \array_keys($this->getKeys());
        foreach ($catalog as $k) {

            if (substr($k, 0, strlen($key)) == $key) {

                $delete = $this->memcache->delete($this->namespace . $key);
                if ($delete) {
                    $this->catalogKeyDelete($k);
                    $deleted = true;
                }
            }
        }

        return $deleted;
    }
372468
public function forget($key)
    {
        $this->table()->where('key', '=', $this->prefix.$key)->delete();

        return true;
    }
877484
protected function static_acceleration_delete($key) {
        unset($this->staticaccelerationarray[$key]);
        if ($this->staticaccelerationsize !== false && isset($this->staticaccelerationkeys[$key])) {
            unset($this->staticaccelerationkeys[$key]);
            $this->staticaccelerationcount--;
        }
        return true;
    }