PHP Memcached::delete方法代码示例

 public function tsli_save_post($post_ID, $post, $update)
 {
     $memcache = new Memcached();
     $memcache->addServer('127.0.0.1', 11211);
     foreach ($post as $key => $value) {
         $memcache->delete(md5(json_encode(array("field" => $key, "id" => $post_ID, "type" => "tsli"))));
         $memcache->delete(md5(json_encode(array("field" => $key, "slug" => $post->post_name, "type" => "tsli"))));
     }
     $memcache->delete(md5(json_encode(array("type" => "tsli", "slug" => $post->post_name))));
     $memcache->delete(md5(json_encode(array("type" => "tsli", "id" => $post_ID))));
 }

 public function delete($key)
 {
     $key = $this->prefix . $key;
     $this->store->delete($key);
     $this->removeFromIndex($key);
     return $this;
 }

 /**
  * 解锁
  * @param unknown $key
  */
 public function release($key)
 {
     $key = $this->prefix . $key;
     if ($this->memcached->get($key) === $this->Identifier) {
         $this->memcached->delete($key);
     }
 }

 /**
  * Delete an item from the cache
  *
  * @param string $key cache key
  */
 public function Delete($key)
 {
     if (empty($key)) {
         return;
     }
     $this->memcache->delete($key);
 }

 /**
  * @param string $name
  */
 public function invalidate($name)
 {
     if (!$this->memcached instanceof \Memcached) {
         $this->connect();
     }
     $this->memcached->delete($name);
 }

 function delete($key)
 {
     $key = str_replace('\\', '/', $key);
     if (!$this->memcached->delete($key)) {
         $message = sprintf('Memcache::delete() with key "%s" failed', $key);
         \ManiaLib\Utils\Logger::error($message);
     }
 }

 public function getCounter()
 {
     $memcached = new \Memcached();
     $memcached->addServer($GLOBALS['settings']['memcached']['host'], $GLOBALS['settings']['memcached']['port']);
     $memcached->delete('prefix/counter/value');
     $memcached->delete('prefix/counter/value2');
     return new \Cachet\Counter\Memcache($memcached, 'prefix');
 }

 /**
  * Release lock
  *
  * @param string $name name of lock
  * @return bool
  */
 public function releaseLock($name)
 {
     if (isset($this->keys[$name]) && $this->memcache->delete($name)) {
         unset($this->keys[$name]);
         return true;
     }
     return false;
 }

 public function testLoadStatusEmpty()
 {
     $this->_connection->delete('EjsmontCircuitBreakerAAAbbb');
     $this->assertEquals("", $this->_adapter->loadStatus('GGG', ''));
     $this->assertEquals("", $this->_adapter->loadStatus('AAA', 'bbb'));
     $this->_adapter->saveStatus('B', 'bbb', "");
     $this->assertEquals("", $this->_adapter->loadStatus('A', 'bbb'), 6);
     $this->assertEquals("", $this->_adapter->loadStatus('B', 'bbb'), 7);
 }

 /**
  * {@inheritdoc}
  */
 protected function deleteArrayDataFromStorage(array $keys)
 {
     $deleted = true;
     foreach ($keys as $key) {
         if ($this->memcached->delete($key) === false) {
             $deleted = false;
         }
     }
     return $deleted;
 }

 public function delete($key)
 {
     $this->memcachedObj->delete($key);
     $resultCode = $this->memcachedObj->getResultCode();
     if ($resultCode != \Memcached::RES_SUCCESS && $resultCode != \Memcached::RES_NOTFOUND) {
         throw new StorageException('[STORAGE] "' . $this->getStorageName() . '::delete" failed for key "' . $key . '"!' . ' StorageRespCode: ' . $resultCode);
     }
     unset($this->casArray[$key]);
     return $resultCode;
 }

 /**
  * {@inheritdoc}
  */
 protected function doDelete($key, array $options = array())
 {
     $this->client->delete($this->getKey($key, $options));
     switch (true) {
         case $this->isSuccess():
             return new CacheResponse(true, true, true);
         case $this->isNotFound():
             return new CacheResponse(false, false, true, CacheResponse::RESOURCE_NOT_FOUND);
     }
     /* If everything failed we're dealing with a backend (connection) error. */
     return new CacheResponse(false, false, false, CacheResponse::CONNECTION_ERROR);
 }

 public function process()
 {
     $id = $this->get('id');
     $state = (string) $this->get('state');
     if (!$this->is_moderator()) {
         throw new ErrorApi(ErrorApi::INSUFFICIENT_RIGHTS);
     }
     if (empty($id) || empty($state)) {
         throw new ErrorApi(ErrorApi::MISSING_INPUT);
     }
     $state = Meta::parse($state);
     if (empty($state)) {
         throw new ErrorApi(ErrorApi::INCORRECT_INPUT);
     }
     $this->db->update('art', array('sortdate' => $this->db->unix_to_date()), $id);
     $this->remove_meta(Meta::ART, $id, Meta::STATE, Meta::STATE_APPROVED);
     $this->remove_meta(Meta::ART, $id, Meta::STATE, Meta::STATE_UNAPPROVED);
     $this->remove_meta(Meta::ART, $id, Meta::STATE, Meta::STATE_DISAPPROVED);
     $this->remove_meta(Meta::ART, $id, Meta::STATE, Meta::STATE_DELETED);
     $this->add_meta(Meta::ART, $id, Meta::STATE, $state);
     $cache = new \Memcached("access_checker");
     $cache->addServer("localhost", 11211);
     $cache->delete('is_pic_safe_' . $this->db->get_field('art', 'md5', $id));
     $this->set_success(true);
 }

 /**
  * Remove a cache record directly. This method is implemented by the cache
  * drivers and used in Doctrine_Cache_Driver::delete()
  *
  * @param string $id cache id
  * @return boolean true if no problem
  */
 protected function _doDelete($id)
 {
     if (false == $this->_memcached->getOption(Memcached::OPT_BINARY_PROTOCOL)) {
         $id = str_replace(' ', '_', $id);
     }
     return $this->_memcached->delete($id);
 }

 /**
  * Delete data tied to a key on the cache server.
  *
  * @param string $key Key we can use to retrieve the data.
  *
  * @return bool True if deleted, false if not.
  * @access public
  */
 public function delete($key)
 {
     if ($this->connected === true && $this->ping() === true) {
         return (bool) $this->server->delete($key);
     }
     return false;
 }