/**
* @see parent::listKeys()
*/
function listKeys($prefix)
{
// Memcached 2.0+
if (method_exists($this->conn, "getAllKeys")) {
return $this->conn->getAllKeys();
}
return array();
}
public function clear($prefix = '')
{
$prefix = $this->getNamespace() . $prefix;
$allKeys = self::$cache->getAllKeys();
$keys = array();
$prefixLength = strlen($prefix);
foreach ($allKeys as $key) {
if (substr($key, 0, $prefixLength) === $prefix) {
$keys[] = $key;
}
}
self::$cache->deleteMulti($keys);
return true;
}
public function clear($prefix = '')
{
$prefix = $this->getNamespace() . $prefix;
$allKeys = self::$cache->getAllKeys();
if ($allKeys === false) {
// newer Memcached doesn't like getAllKeys(), flush everything
self::$cache->flush();
return true;
}
$keys = array();
$prefixLength = strlen($prefix);
foreach ($allKeys as $key) {
if (substr($key, 0, $prefixLength) === $prefix) {
$keys[] = $key;
}
}
if (method_exists(self::$cache, 'deleteMulti')) {
self::$cache->deleteMulti($keys);
} else {
foreach ($keys as $key) {
self::$cache->delete($key);
}
}
return true;
}
public function mem()
{
//$CI =& get_instance();
$m = new Memcached();
$m->addServer('localhost', 11211);
$res = $m->getAllKeys();
print_r($res);
}
/**
* Delete all keys from the cache
*
* @param bool $check If true will check expiration, otherwise delete all.
* @return bool True if the cache was successfully cleared, false otherwise
*/
public function clear($check)
{
if ($check) {
return true;
}
$keys = $this->_Memcached->getAllKeys();
foreach ($keys as $key) {
if (strpos($key, $this->_config['prefix']) === 0) {
$this->_Memcached->delete($key);
}
}
return true;
}
public static function keys(\Memcached $memcached, $regex = false)
{
$allKeys = $memcached->getAllKeys();
if (!$regex) {
return $allKeys;
}
$matchingKeys = [];
foreach ($allKeys as $key) {
if (preg_match($regex, $key) > 0) {
array_push($matchingKeys, $key);
}
}
return $matchingKeys;
}
/**
* Delete one or several data from cache (* joker can be used, but avoid it !)
* E.g.: delete('*'); delete('my_prefix_*'); delete('my_key_name');
*
* @param string $key
* @return bool
*/
public function delete($key)
{
if ($key == '*') {
$this->flush();
} elseif (strpos($key, '*') === false) {
$this->_delete($key);
} else {
$pattern = str_replace('\\*', '.*', preg_quote($key));
$keys = $this->memcached->getAllKeys();
foreach ($keys as $key => $data) {
if (preg_match('#^' . $pattern . '$#', $key)) {
$this->_delete($key);
}
}
}
return true;
}
protected function flushImpl($cacheSubsetName) {
if (isset($cacheSubsetName)) {
$cacheEntryNames = $this->memcached->getAllKeys();
if ($cacheEntryNames === FALSE) {
return FALSE;
}
$result = TRUE;
foreach ($cacheEntryNames as $cacheEntryName) {
if ($this->inSubset($cacheSubsetName, $cacheEntryName)) {
$result = $this->memcached->delete($cacheEntryName) && $result;
}
}
return $result;
}
else {
return $this->memcached->flush();
}
}
/**
* {@inheritDoc}
*
* @see http://php.net/manual/en/memcached.getallkeys.php
*/
protected function _getAllKeys()
{
return $this->_connection->getAllKeys();
}
<?php
$m = new Memcached();
$m->addServer('localhost', 11211);
// getAllKeys doesn't seem to work until after another operation
$m->get('a');
$keys = $m->getAllKeys();
if ($keys) {
array_map(function ($key) use($m) {
$m->delete($key);
}, $keys);
}
var_dump($m->getAllKeys());
$obj = new stdclass();
$obj->int = 99;
$obj->string = 'a simple string';
$obj->array = array(11, 22);
$m->set('int', 99);
$m->set('string', 'a simple string');
$m->set('array', array(11, 12));
$m->set('object', $obj);
var_dump($m->getAllKeys());
/**
* Returns all of the keys in the given connection that belong to this cache store instance.
*
* Requires php memcached extension version 2.0.0 or greater.
*
* @param Memcached $connection
* @param string $prefix
* @return array
*/
protected static function get_prefixed_keys(Memcached $connection, $prefix)
{
$connkeys = $connection->getAllKeys();
if (empty($connkeys)) {
return array();
}
$keys = array();
$start = strlen($prefix);
foreach ($connkeys as $key) {
if (strpos($key, $prefix) === 0) {
$keys[] = substr($key, $start);
}
}
return $keys;
}
$listKeys = true;
// key
} else {
$key = trim($arg);
}
}
}
$mc = new Memcached();
$mc->setOption(\Memcached::OPT_LIBKETAMA_COMPATIBLE, true);
$mc->setOption(\Memcached::OPT_DISTRIBUTION, \Memcached::DISTRIBUTION_CONSISTENT);
$mc->addServer($host, $port);
$keys = [];
if ($key && strpos($key, '*') === false) {
$keys[] = $key;
} else {
$allKeys = $mc->getAllKeys();
if (strpos($key, '*') !== false) {
$keyPattern = '/^' . str_replace('*', '.*', $key) . '$/i';
foreach ($allKeys as $k) {
if (preg_match($keyPattern, $k)) {
$keys[] = $k;
}
}
} elseif ($listKeys) {
$keys = $allKeys;
}
}
foreach ($keys as $key) {
if ($listKeys) {
echo $key . PHP_EOL;
} else {
/**
* tüm memcache key'lerini get eder
* @return array
*/
public function getAllKeys()
{
return $this->memcache->getAllKeys();
}
function cleancache($uid)
{
$m = new Memcached();
$m->addServer('localhost', 11211);
$r = $m->getAllKeys();
$m->delete($uid . 'CE');
$m->delete('dates' . $uid);
$m->delete($uid . 'ext');
$m->delete($uid . 'saldo');
echo 1;
}
/**
* @inheritdoc
*/
public function getAllKeys()
{
return $this->storage->getAllKeys();
}
/**
* Fetch an array of all keys stored in cache
*
* @return array Returns the array of cache keys
*/
protected function _getCacheKeys()
{
return $this->_memcached->getAllKeys();
}
function mem()
{
$m = new Memcached();
$m->addServer('localhost', 11211);
$r = $m->getAllKeys();
foreach ($r as $k) {
$v = $m->get($k);
echo $k . ' = ';
print_r($v);
echo '<hr>';
}
}
<?php
/**
* Created by PhpStorm.
* User: Marcin Wojcik
* Date: 10/24/15
* Time: 11:41 AM
*/
$mem = new Memcached();
$mem->addServer("127.0.0.1", 11211);
$list = $mem->getAllKeys();
print_r($list);
$mem->set("blah", "This is memcached value for blah!");
$result = $mem->get("blah");
print_r($result);
<?php
$m = new Memcached('doctrine2');
$m->addServer('localhost', 11211);
$m->set('int', 99);
$m->set(str_replace(' ', '_', 'int con spazi'), 99, 30);
$m->set('string', 'a simple string');
$m->set('array', array(11, 12));
var_dump($m->getAllKeys(), $m->get('int'), $m->get('int con spazi'));
//sleep(3);
//var_dump($m->getAllKeys(), $m->get('int'), $m->get('int con spazi'));
/*
$m2 = new Memcache();
$m2->addServer('localhost', 11211);
$m2->set('int', 99);
$m2->set('string', 'a simple string');
$m2->set('array', array(11, 12));
$keys = array();
$allSlabs = $m2->getExtendedStats('slabs');
foreach ($allSlabs as $server => $slabs) {
foreach (array_keys($slabs) as $slabId) {
$dump = $m2->getExtendedStats('cachedump', (int) $slabId);
foreach ($dump as $entries) {
if ($entries) {
$keys = array_merge($keys, array_keys($entries));
}
}
/**
* @inheritdoc
*/
public function getAllKeys()
{
$keys = parent::getAllKeys();
foreach ($keys as $key => $cacheKey) {
if (strpos($cacheKey, $this->prefix) !== 0) {
unset($keys[$key]);
}
}
return $keys;
}
