delete method multiserver pools

@param $server_key string
@param $key        string
@param $time       int

@return boolean
559966
public function deleteByKey($server_key, $key, $time = 0)
    {

        if (parent::deleteByKey($server_key, $key, ($time ? $time : null))) {
            unset($this->cacheListing [$key]);
            $this->saveCacheListing();

            return true;
        }

        return false;
    }
850765
public function deleteAfterDays($bucket, $key, $days){
        $err = $this->bucketManager->deleteAfterDays($bucket, $key, $days);
        if($err){
            return $this->error($err->message(), ['errorCode'=>$err->code()]);
        }
        return $this->success('操作成功');
    }
882330
public function deleteFromList($key_array = array())
    {

        if (empty($key_array)) return false;

        foreach ($key_array as $key_del) {
            if (empty($this->cacheListing)) break;
            foreach ($this->cacheListing as $key) {
                if (mb_strpos(mb_strtolower($key), mb_strtolower($key_del)) !== false) $this->delete($key);
            }
        }

        return true;
    }
719266
public function forget($key)
    {
        if (false === is_resource($this->dba)) {
            return false;
        }

        return dba_delete($key, $this->dba);
    }
1123361
public function deleteFromList($key_array = array())
    {
        if (empty ($key_array))
            return false;

        foreach ($key_array as $key_del) {
            if (empty ($this->cacheListing)) {
                break;
            }

            foreach ($this->cacheListing as $key) {
                if (strpos(strtolower($key), strtolower($key_del) !== false)) {
                    $this->delete($key);
                }
            }
        }

        return true;
    }
129234
public function delete(string $key, int $time = 0) : bool
    {
        $this->removeCount++;
        unset($this->entryMetaData[$key], $this->store[$key]);
        return true;
    }
944057
def delete(self, conn, key):
        
        assert self._validate_key(key)

        command = b'delete ' + key + b'\r\n'
        response = yield from self._execute_simple_command(conn, command)

        if response not in (const.DELETED, const.NOT_FOUND):
            raise ClientException('Memcached delete failed', response)
        return response == const.DELETED
855039
public function remove( $key )
	{
		if( !isset( $GLOBALS[$this->poolKey][$key] ) )
			return false;
		unset( $GLOBALS[$this->poolKey][$key] );
		return true;	
	}
23211
def delete_server_subscribers(channel)
      @server.mutex.synchronize do
        (@server.subscribers[channel] || []).delete_if do |hash|
          hash[:reactor] == Actor.current
        end
      end
    end
1093262
public function drop($key) {
        $fileName = $this->getFilePath($key);

        if (is_file($fileName)) {
            if (unlink($fileName)) {
                clearstatcache();

                $this->getReferencePool()->drop($key);
                return true;
            }
            throw new RuntimeException('Cannot delete file: '.$fileName);
        }

        return false;
    }
467037
def delete(self, stream, start_time, end_time, start_id=None, namespace=None):
    
    if isinstance(start_time, types.StringTypes):
      start_time = parse(start_time)
    if isinstance(end_time, types.StringTypes):
      end_time = parse(end_time)
    if isinstance(start_time, datetime):
      start_time = datetime_to_kronos_time(start_time)
    if isinstance(end_time, datetime):
      end_time = datetime_to_kronos_time(end_time)
    request_dict = {
      'stream': stream,
      'end_time': end_time
    }
    if start_id:
      request_dict['start_id'] = start_id
    else:
      request_dict['start_time'] = start_time

    namespace = namespace or self.namespace
    if namespace is not None:
      request_dict['namespace'] = namespace

    return self._make_request(self._delete_url, data=request_dict)
60181
public final void deleteWithNoReply(final String key, final int time)
      throws InterruptedException, MemcachedException {
    try {
      this.delete0(key, time, 0, true, this.opTimeout);
    } catch (TimeoutException e) {
      throw new MemcachedException(e);
    }
  }
691642
public function deleteByPK(array $primary_key)
    {
        $where = $this
            ->checkPrimaryKey($primary_key)
            ->getWhereFrom($primary_key)
        ;

        return $this->deleteWhere($where)->current();
    }
26355
public function appendByKey(string $server_key, string $key, string $value) {
    return $this->append($key, $value);
  }
293802
public static function delete($key)
    {
        empty(self::$prefix) && self::$prefix = Config::get('session_prefix');
        if (is_array($key)) {
            foreach ($key as $k) {
                if (isset($_SESSION[self::$prefix . $k])) unset($_SESSION[self::$prefix . $k]);
            }
        } else {
            if (isset($_SESSION[self::$prefix . $key])) unset($_SESSION[self::$prefix . $key]);
        }
        return true;
    }
121832
public function delete($key, $onResponse = null, $time = 0)
    {
        $this->getConnectionByKey($key, function ($conn) use ($key, $time, $onResponse) {
            if (!$conn->connected) {
                return;
            }
            if ($onResponse !== null) {
                $conn->onResponse->push($onResponse);
                $conn->checkFree();
            }
            $conn->writeln('delete ' . $this->config->prefix->value . $key . ' ' . $time);
        });
    }
154223
def server_delete(s_name, **connection_args):
    '''
    
    '''
    ret = True
    server = _server_get(s_name, **connection_args)
    if server is None:
        return False
    nitro = _connect(**connection_args)
    if nitro is None:
        return False
    try:
        NSServer.delete(nitro, server)
    except NSNitroError as error:
        log.debug('netscaler module error - NSServer.delete() failed: %s', error)
        ret = False
    _disconnect(nitro)
    return ret