PHP Memcached::append方法代码示例

 /**
  * {@inheritdoc}
  */
 public function add(string $alias, FeatureInterface $feature) : StorageInterface
 {
     $key = $this->key($alias);
     $this->memcached->set($key, $this->feature($feature));
     if (!$this->memcached->append($this->prefix, "|{$key}")) {
         $this->memcached->set($this->prefix, $key);
     }
     return $this;
 }

 /**
  * Append data to an existing item.
  *
  * This method should throw an error if it is used with compressed data. This
  * is an expected behavior. Memcached casts the value to be appended to the initial value to the
  * type of the initial value. Be careful as this leads to unexpected behavior at times. Due to
  * how memcached treats types, the behavior has been mimicked in the internal cache to produce
  * similar results and improve consistency. It is recommend that appends only occur with data of
  * the same type.
  *
  * @link    http://www.php.net/manual/en/memcached.append.php
  *
  * @param   string      $key            The key under which to store the value.
  * @param   mixed       $value          Must be string as appending mixed values is not well-defined.
  * @param   string      $group          The group value appended to the $key.
  * @param   string      $server_key     The key identifying the server to store the value on.
  * @param   bool        $byKey          True to store in internal cache by key; false to not store by key
  * @return  bool                        Returns TRUE on success or FALSE on failure.
  */
 public function append($key, $value, $group = 'default', $server_key = '', $byKey = false)
 {
     if (!is_string($value) && !is_int($value) && !is_float($value)) {
         return false;
     }
     $derived_key = $this->buildKey($key, $group);
     // If group is a non-Memcached group, append to runtime cache value, not Memcached
     if (in_array($group, $this->no_mc_groups)) {
         if (!isset($this->cache[$derived_key])) {
             return false;
         }
         $combined = $this->combine_values($this->cache[$derived_key], $value, 'app');
         $this->add_to_internal_cache($derived_key, $combined);
         return true;
     }
     // Append to Memcached value
     if (false !== $byKey) {
         $result = $this->mc->appendByKey($server_key, $derived_key, $value);
     } else {
         $result = $this->mc->append($derived_key, $value);
     }
     // Store in runtime cache if add was successful
     if (Memcached::RES_SUCCESS === $this->getResultCode()) {
         $combined = $this->combine_values($this->cache[$derived_key], $value, 'app');
         $this->add_to_internal_cache($derived_key, $combined);
     }
     return $result;
 }

 /**
  * Appends a value to the end of an existing cached value.
  *
  * If the value doesn't exist, it will be set with the given value
  *
  * @param String $key The key for the value
  * @param mixed $value The value to append
  * @param Integer $expire The lifespan of this cache value, in seconds
  * @return \r8\Cache\Memcached Returns a self reference
  */
 public function append($key, $value, $expire = 0)
 {
     if (!$this->memcached->append($this->prepareKey($key), (string) $value)) {
         $this->set($key, $value, $expire);
     }
     $this->handleErrors();
     return $this;
 }

 public function append($key, $data)
 {
     $this->ensureTriedToConnect();
     try {
         return $this->instance->append($key, $data);
     } catch (BaseException $e) {
         return $this->alive = false;
     }
 }

 /**
  * {@inheritdoc }
  */
 public function has($key)
 {
     /* It seems that the most efficient way to check has in memcached is
        by using an append with an empty string. However, we need to make
        sure that OPT_COMPRESSION is turned off because you can't append
        if you compressing data */
     /* store for later use */
     $cur_compression = $this->adapter->getOption(BaseMemcached::OPT_COMPRESSION);
     /* set compression off */
     $this->adapter->setOption(BaseMemcached::OPT_COMPRESSION, false);
     $res = $this->adapter->append($this->buildKey($key), '');
     $this->adapter->setOption(BaseMemcached::OPT_COMPRESSION, $cur_compression);
     return $res;
 }

 /**
  * 向已存在元素后追加数据
  * @param string|array $key
  * @param mixed $value
  */
 public function append($key = NULL, $value = NULL)
 {
     $this->local_cache[$this->key_name($key)] = $value;
     switch ($this->client_type) {
         case 'Memcache':
             $append_status = $this->m->append($this->key_name($key), $value);
             break;
         default:
         case 'Memcached':
             $append_status = $this->m->append($this->key_name($key), $value);
             break;
     }
     return $append_status;
 }

 public function testAppendCasRaceFailed()
 {
     $request = new MemcacheGetRequest();
     $request->addKey("widgets_float");
     $request->setForCas(true);
     $response = new MemcacheGetResponse();
     $item = $response->addItem();
     $item->setKey("widgets_float");
     $item->setValue("bar");
     $item->setFlags(0);
     // string.
     $item->setCasId(123456);
     $this->apiProxyMock->expectCall('memcache', 'Get', $request, $response);
     $request = new MemcacheSetRequest();
     $item = $request->addItem();
     $item->setKey("widgets_float");
     $item->setValue("barfoo");
     $item->setFlags(0);
     // string
     $item->setCasId(123456);
     $item->setSetPolicy(SetPolicy::CAS);
     $item->setExpirationTime(0);
     $response = new MemcacheSetResponse();
     $response->addSetStatus(SetStatusCode::EXISTS);
     $this->apiProxyMock->expectCall('memcache', 'Set', $request, $response);
     $request = new MemcacheGetRequest();
     $request->addKey("widgets_float");
     $request->setForCas(true);
     $response = new MemcacheGetResponse();
     $item = $response->addItem();
     $item->setKey("widgets_float");
     $item->setValue("baz");
     $item->setFlags(0);
     // string.
     $item->setCasId(1234567);
     $this->apiProxyMock->expectCall('memcache', 'Get', $request, $response);
     $request = new MemcacheSetRequest();
     $item = $request->addItem();
     $item->setKey("widgets_float");
     $item->setValue("bazfoo");
     $item->setFlags(0);
     // string
     $item->setCasId(1234567);
     $item->setSetPolicy(SetPolicy::CAS);
     $item->setExpirationTime(0);
     $response = new MemcacheSetResponse();
     $response->addSetStatus(SetStatusCode::STORED);
     $this->apiProxyMock->expectCall('memcache', 'Set', $request, $response);
     $memcached = new Memcached();
     $memcached->setOption(Memcached::OPT_PREFIX_KEY, "widgets_");
     $this->assertTrue($memcached->append("float", "foo", 30));
     $this->assertEquals($memcached->getResultCode(), Memcached::RES_SUCCESS);
     $this->apiProxyMock->verify();
 }

<?php

$cache = new Memcached();
$cache->setOption(Memcached::OPT_BINARY_PROTOCOL, true);
$cache->setOption(Memcached::OPT_COMPRESSION, false);
$cache->addServer('localhost', 3434);
$cache->add("add_key", "hello", 500);
$cache->append("append_key", "world");
$cache->prepend("prepend_key", "world");
$cache->increment("incr", 2, 1, 500);
$cache->decrement("decr", 2, 1, 500);
$cache->delete("delete_k");
$cache->flush(1);
var_dump($cache->get('get_this'));
$cache->set('set_key', 'value 1', 100);
$cache->replace('replace_key', 'value 2', 200);
$cache->getStats();
$cache->quit();
sleep(1);

 /**
  * @inheritdoc
  */
 public function append($key, $value, $expiration = null)
 {
     $key = $this->prefix . $key;
     return parent::append($key, $value, $expiration);
 }