/**
* @param string[] $keys
* @return mixed[]
*/
public function multiGet(string ...$keys) : array
{
if (count($keys) === 0) {
return [];
}
return $this->client->getMulti($keys);
}
/**
* {@inheritdoc}
*/
public function getMulti(array $keys, array &$tokens = null)
{
$return = $this->client->getMulti($keys, $tokens);
// HHVMs getMulti() returns null instead of empty array for no results,
// so normalize that
$tokens = $tokens ?: array();
return $return ?: array();
}
/**
* {@inheritdoc}
*/
protected function getArrayDataFromStorage(array $keys)
{
$result = $this->memcached->getMulti($keys);
if ($result === false) {
return [];
}
return $result;
}
public function multiRead($keys)
{
$cas = null;
$values = $this->store->getMulti($keys, $cas, Memcached::GET_PRESERVE_ORDER);
if (!$values) {
$values = array_fill_keys($keys, null);
}
return $values;
}
/**
* Read values for a set of keys from cache
*
* @param array $keys list of keys to fetch
*
* @return array list of values with the given keys used as indexes
* @return boolean true on success, false on failure
*/
protected function read(array $keys)
{
$_keys = $lookup = [];
list($_keys, $lookup) = $this->eachKeys($keys, $_keys, $lookup);
$_res = [];
$res = $this->memcached->getMulti($_keys);
foreach ($res as $k => $v) {
$_res[$lookup[$k]] = $v;
}
return $_res;
}
/**
* Retrieve multiple items from the cache by key.
*
* Items not found in the cache will have a null value.
*
* @param array $keys
* @return array
*/
public function many(array $keys)
{
$prefixedKeys = array_map(function ($key) {
return $this->prefix . $key;
}, $keys);
$values = $this->memcached->getMulti($prefixedKeys, null, Memcached::GET_PRESERVE_ORDER);
if ($this->memcached->getResultCode() != 0) {
return array_fill_keys($keys, null);
}
return array_combine($keys, $values);
}
/**
* {@inheritdoc}
*/
public function getMulti(array $keys, array &$tokens = null)
{
$keys = array_map(array($this, 'encodeKey'), $keys);
$return = $this->client->getMulti($keys, $tokens);
$keys = array_map(array($this, 'decodeKey'), array_keys($return));
$return = array_combine($keys, $return);
// HHVMs getMulti() returns null instead of empty array for no results,
// so normalize that
$tokens = $tokens ?: array();
$tokens = array_combine($keys, $tokens);
return $return ?: array();
}
/**
* 获取多条数据记录
* @param array $keys
* @return mixed
*/
public function getMulti(array $keys)
{
//保证返回的key的顺序和请求时一致
$data = $this->dbh->getMulti($keys, $cas, \Memcached::GET_PRESERVE_ORDER);
if ($data === false) {
if ($this->dbh->getResultCode() == \Memcached::RES_NOTFOUND) {
return array();
} else {
$this->error('getMulti', json_encode($keys));
}
}
return $data;
}
/**
* Get multiple values from the cache.
*
* @param array $keys An array of keys to get
*
* @return array An array of JSON objects
*/
public function mget(array $keys = array())
{
$values = $this->client->getMulti($keys);
$rtn = [];
// The Memcached extension returns false not null for nonexistent
// values. For consistency's sake, we spoof that here
foreach ($keys as $key) {
if (!isset($values[$key]) || $values[$key] === false) {
$values[$key] = null;
}
$rtn[$this->instance->unkey($key)] = $values[$key];
}
return $rtn;
}
public function getMulti($keys)
{
$result = new MultiGetResult($keys);
$null = null;
$cached = $this->memcached->getMulti(array_keys($keys), $null, \Memcached::GET_PRESERVE_ORDER);
foreach ($cached as $key => $value) {
if (null === $value) {
$id = $keys[$key];
$result->miss($id, $key);
} else {
$result->hit($key, $value);
}
}
return $result;
}
/**
* Get multiple items.
*
* Options:
* - ttl <float> optional
* - The time-to-life (Default: ttl of object)
* - namespace <string> optional
* - The namespace to use (Default: namespace of object)
*
* @param array $keys
* @param array $options
* @return array Assoziative array of existing keys and values or false on failure
* @throws Exception
*
* @triggers getItems.pre(PreEvent)
* @triggers getItems.post(PostEvent)
* @triggers getItems.exception(ExceptionEvent)
*/
public function getItems(array $keys, array $options = array())
{
$baseOptions = $this->getOptions();
if (!$baseOptions->getReadable()) {
return array();
}
$this->normalizeOptions($options);
$args = new ArrayObject(array('keys' => &$keys, 'options' => &$options));
try {
$eventRs = $this->triggerPre(__FUNCTION__, $args);
if ($eventRs->stopped()) {
return $eventRs->last();
}
$namespaceSep = $baseOptions->getNamespaceSeparator();
$internalKeys = array();
foreach ($keys as $key) {
$internalKeys[] = $options['namespace'] . $namespaceSep . $key;
}
$fetch = $this->memcached->getMulti($internalKeys);
if ($fetch === false) {
throw new Exception\ItemNotFoundException('Memcached::getMulti(<array>) failed');
}
// remove namespace prefix
$prefixL = strlen($options['namespace'] . $namespaceSep);
$result = array();
foreach ($fetch as $internalKey => &$value) {
$result[substr($internalKey, $prefixL)] = $value;
}
return $this->triggerPost(__FUNCTION__, $args, $result);
} catch (\Exception $e) {
return $this->triggerException(__FUNCTION__, $args, $e);
}
}
/**
* @Name get 根据键名获取值
*
* @param string $key key
* @return array OR json object OR string...
* add by cheng.yafei
*
*/
public function get($key = NULL)
{
if ($this->m) {
$keyName = $this->key_name($key);
if (isset($this->local_cache[$keyName])) {
return $this->local_cache[$keyName];
}
if (is_null($key)) {
$this->errors[] = 'The key value cannot be NULL';
return false;
}
if (is_array($key)) {
foreach ($key as $n => $k) {
$key[$n] = $this->key_name($k);
}
return $this->m->getMulti($key);
} else {
$obj = $this->m->get($keyName);
$this->local_cache[$keyName] = $obj;
return $obj;
}
} else {
return false;
}
}
/**
* Read cached data
*
* @param array $keys array of keys to load
* @return array key/value cached data
*/
protected function read(array $keys)
{
$keymap = array();
$hashedkeys = array();
foreach ($keys as $key) {
$newkey = sha1($key);
$keymap[$newkey] = $key;
$hashedkeys[] = $newkey;
}
$data = false;
$cachedata = array();
if ($this->memcacheType == GitPHP_CacheResource_Memcache::Memcache) {
$cachedata = $this->memcacheObj->get($hashedkeys);
} else {
if ($this->memcacheType == GitPHP_CacheResource_Memcache::Memcached) {
$cachedata = $this->memcacheObj->getMulti($hashedkeys);
}
}
if ($cachedata) {
foreach ($cachedata as $key => $value) {
$origkey = $keymap[$key];
if (!empty($origkey)) {
$data[$origkey] = $value;
}
}
}
return $data;
}
public function getCounters()
{
$counters = array();
$result = $this->memcache->getMulti(array($this->prefix . 'hit', $this->prefix . 'miss', $this->prefix . 'error'));
$counters['hit'] = array_key_exists($this->prefix . 'hit', $result) ? $result[$this->prefix . 'hit'] : 0;
$counters['miss'] = array_key_exists($this->prefix . 'miss', $result) ? $result[$this->prefix . 'miss'] : 0;
$counters['error'] = array_key_exists($this->prefix . 'error', $result) ? $result[$this->prefix . 'error'] : 0;
$counters['age'] = $this->getReportAge();
return $counters;
}
/**
* Get metadata of multiple items
*
* @param array $normalizedKeys
* @return array Associative array of keys and metadata
* @throws Exception\ExceptionInterface
*/
protected function internalGetMetadatas(array &$normalizedKeys)
{
$result = $this->memcached->getMulti($normalizedKeys);
if ($result === false) {
throw $this->getExceptionByResultCode($this->memcached->getResultCode());
}
foreach ($result as &$value) {
$value = array();
}
return $result;
}
/**
* Get metadata of multiple items
*
* Options:
* - namespace <string> optional
* - The namespace to use
*
* @param array $normalizedKeys
* @param array $normalizedOptions
* @return array
* @throws Exception\ExceptionInterface
*
* @triggers getMetadatas.pre(PreEvent)
* @triggers getMetadatas.post(PostEvent)
* @triggers getMetadatas.exception(ExceptionEvent)
*/
protected function internalGetMetadatas(array &$normalizedKeys, array &$normalizedOptions)
{
$this->memcached->setOption(MemcachedResource::OPT_PREFIX_KEY, $normalizedOptions['namespace']);
$result = $this->memcached->getMulti($normalizedKeys);
if ($result === false) {
throw $this->getExceptionByResultCode($this->memcached->getResultCode());
}
foreach ($result as $key => &$value) {
$value = array();
}
return $result;
}
/**
* Gets multiple values from memcached in one request.
*
* See the buildKeys method definition to understand the $keys/$groups parameters.
*
* @link http://www.php.net/manual/en/memcached.getmulti.php
*
* @param array $keys Array of keys to retrieve.
* @param string|array $groups If string, used for all keys. If arrays, corresponds with the $keys array.
* @param string $server_key The key identifying the server to store the value on.
* @param null|array $cas_tokens The variable to store the CAS tokens for the found items.
* @param int $flags The flags for the get operation.
* @return bool|array Returns the array of found items or FALSE on failure.
*/
public function getMulti($keys, $groups = 'default', $server_key = '', &$cas_tokens = NULL, $flags = NULL)
{
$derived_keys = $this->buildKeys($keys, $groups);
/**
* If either $cas_tokens, or $flags is set, must hit Memcached and bypass runtime cache. Note that
* this will purposely ignore no_mc_groups values as they cannot handle CAS tokens or the special
* flags; however, if the groups of groups contains a no_mc_group, this is bypassed.
*/
if (func_num_args() > 3 && !$this->contains_no_mc_group($groups)) {
if (!empty($server_key)) {
$values = $this->mc->getMultiByKey($server_key, $derived_keys, $cas_tokens, $flags);
} else {
$values = $this->mc->getMulti($derived_keys, $cas_tokens, $flags);
}
} else {
$values = array();
$need_to_get = array();
// Pull out values from runtime cache, or mark for retrieval
foreach ($derived_keys as $key) {
if (isset($this->cache[$key])) {
$values[$key] = $this->cache[$key];
} else {
$need_to_get[$key] = $key;
}
}
// Get those keys not found in the runtime cache
if (!empty($need_to_get)) {
if (!empty($server_key)) {
$result = $this->mc->getMultiByKey($server_key, array_keys($need_to_get));
} else {
$result = $this->mc->getMulti(array_keys($need_to_get));
}
}
// Merge with values found in runtime cache
if (isset($result) && Memcached::RES_SUCCESS === $this->getResultCode()) {
$values = array_merge($values, $result);
}
// If order should be preserved, reorder now
if (!empty($need_to_get) && $flags === Memcached::GET_PRESERVE_ORDER) {
$ordered_values = array();
foreach ($derived_keys as $key) {
if (isset($values[$key])) {
$ordered_values[$key] = $values[$key];
}
}
$values = $ordered_values;
unset($ordered_values);
}
}
// Add the values to the runtime cache
$this->cache = array_merge($this->cache, $values);
return $values;
}
/**
* Retrieves several items from the cache store in a single transaction.
*
* If not all of the items are available in the cache then the data value for those that are missing will be set to false.
*
* @param array $keys The array of keys to retrieve
* @return array An array of items from the cache. There will be an item for each key, those that were not in the store will
* be set to false.
*/
public function get_many($keys)
{
$result = $this->connection->getMulti($keys);
if (!is_array($result)) {
$result = array();
}
foreach ($keys as $key) {
if (!array_key_exists($key, $result)) {
$result[$key] = false;
}
}
return $result;
}
/**
* @param array $keys
* @return array
*/
protected function fetchMultiObjectsFromCache(array $keys)
{
$items = [];
$result = $this->cache->getMulti($keys, $null, \Memcached::GET_PRESERVE_ORDER);
foreach ($result as $key => $value) {
$cacheItem = new CacheItem($key);
if (false !== ($result = unserialize($this->cache->get($key)))) {
$cacheItem->set($result);
}
$items[$key] = $cacheItem;
}
return $items;
}
/**
* 批量获取键值
* @param array $keys 键名数组
* @return array|false 键值数组,失败返回false
*/
public function mGet($keys)
{
try {
$ret = [];
$values = $this->handler->getMulti($keys);
foreach ($keys as $key) {
$ret[$key] = isset($values[$key]) ? self::getValue($values[$key]) : false;
}
return $ret;
} catch (Exception $ex) {
self::exception($ex);
//连接状态置为false
$this->isConnected = false;
}
return false;
}
/**
* @param array
* @throws RunTimeException
* @return array
*/
public function all(array $ids)
{
$this->keys = array();
$this->keys = preg_filter('/^/', $this->table . '_', $ids);
$data = $this->Memcached->getMulti($this->keys);
if ($data === false) {
$msg = $this->Memcached->getResultMessage();
$code = $this->Memcached->getResultCode();
throw new \RunTimeException("Memcached Error (all): " . $msg . "(" . $code . ")");
}
$result = array();
foreach ($data as $key => $val) {
$result[str_replace($this->table . '_', '', $key)] = json_decode(gzuncompress($val), true);
}
return $result;
}
protected function loadValuesImpl(array $cacheEntryNames) {
$values = $this->memcached->getMulti($cacheEntryNames);
if ($values === FALSE) {
if ($this->memcached->getResultCode() != Memcached::RES_NOTFOUND) {
LogHelper::log_error(t(
'[@cacheType] Could not get values (@cacheEntryNames): @message',
array(
'@cacheType' => self::CACHE__TYPE,
'@cacheEntryNames' => implode(', ', $cacheEntryNames),
'@message' => $this->memcached->getResultMessage())));
}
}
return $values;
}
/**
*
*/
public function getMulti(array $keys, &$cas_tokens = null, $flags = null)
{
if ($this->_noCache) {
return array();
}
// $_test = ($this->_baseKey !== false);
// if ($_test) {
// $keys = array_flip($keys);
// $keys = $this->_translateKeys($keys);
// $keys = array_keys($keys);
// }
$_ret = $this->_memcached->getMulti($keys, $cas_tokens, $flags);
if (!empty($_ret)) {
$_ret = $this->_reverttranslation($_ret);
}
return $_ret;
}
/**
* @param array $ids
* @return array id=>object
*/
protected function _load(array $ids = array())
{
if (!$this->memcached) {
return array();
}
$_idsCopy = array_flip($ids);
// Array transformation : array[id] = id INTO array[memcachedId] = id
array_walk($_idsCopy, function (&$value, $key, $context) {
$value = $context->getMemcachedCompleteKey($key);
// "ev:mc:obj:" . $value;
}, $this);
$_memcachedFormattedIds = array_flip($_idsCopy);
// unserialized & store locally
$_objectsFromCache = $this->memcached->getMulti(array_keys($_memcachedFormattedIds));
$_objects = array();
foreach ($_objectsFromCache as $_memcachedKey => &$_objectFromCache) {
if ($_objectFromCache->getVersion() == $_objectFromCache::VERSION) {
$_objects[$_memcachedFormattedIds[$_memcachedKey]] = $_objectFromCache;
}
}
return $_objects;
}
/**
* Get multiple items.
*
* Options:
* - namespace <string> optional
* - The namespace to use (Default: namespace of object)
*
* @param array $keys
* @param array $options
* @return array Assoziative array of existing keys and values or false on failure
* @throws Exception
*
* @triggers getItems.pre(PreEvent)
* @triggers getItems.post(PostEvent)
* @triggers getItems.exception(ExceptionEvent)
*/
public function getItems(array $keys, array $options = array())
{
$baseOptions = $this->getOptions();
if (!$baseOptions->getReadable()) {
return array();
}
$this->normalizeOptions($options);
$args = new ArrayObject(array('keys' => &$keys, 'options' => &$options));
try {
$eventRs = $this->triggerPre(__FUNCTION__, $args);
if ($eventRs->stopped()) {
return $eventRs->last();
}
$this->memcached->setOption(MemcachedResource::OPT_PREFIX_KEY, $options['namespace']);
$result = $this->memcached->getMulti($keys);
if ($result === false) {
throw $this->getExceptionByResultCode($this->memcached->getResultCode());
}
return $this->triggerPost(__FUNCTION__, $args, $result);
} catch (\Exception $e) {
return $this->triggerException(__FUNCTION__, $args, $e);
}
}
/**
* Returns the `group value` for each of the configured groups
* If the group initial value was not found, then it initializes
* the group accordingly.
*
* @return array
*/
public function groups()
{
if (empty($this->_compiledGroupNames)) {
foreach ($this->_config['groups'] as $group) {
$this->_compiledGroupNames[] = $this->_config['prefix'] . $group;
}
}
$groups = $this->_Memcached->getMulti($this->_compiledGroupNames);
if (count($groups) !== count($this->_config['groups'])) {
foreach ($this->_compiledGroupNames as $group) {
if (!isset($groups[$group])) {
$this->_Memcached->set($group, 1, 0);
$groups[$group] = 1;
}
}
ksort($groups);
}
$result = [];
$groups = array_values($groups);
foreach ($this->_config['groups'] as $i => $group) {
$result[] = $group . $groups[$i];
}
return $result;
}
/**
* Reads from cache in bulk.
* @param string key
* @return array key => value pairs, missing items are omitted
*/
public function bulkRead(array $keys)
{
$prefixedKeys = array_map(function ($key) {
return urlencode($this->prefix . $key);
}, $keys);
$keys = array_combine($prefixedKeys, $keys);
$metas = $this->memcached->getMulti($prefixedKeys);
$result = [];
$deleteKeys = [];
foreach ($metas as $prefixedKey => $meta) {
if (!empty($meta[self::META_CALLBACKS]) && !Cache::checkCallbacks($meta[self::META_CALLBACKS])) {
$deleteKeys[] = $prefixedKey;
} else {
$result[$keys[$prefixedKey]] = $meta[self::META_DATA];
}
if (!empty($meta[self::META_DELTA])) {
$this->memcached->replace($prefixedKey, $meta, $meta[self::META_DELTA] + time());
}
}
if (!empty($deleteKeys)) {
$this->memcached->deleteMulti($deleteKeys, 0);
}
return $result;
}
//$m->set($shareKey,0,360);
//$m->set('share_ok',0,360);
$items = array('share_ok' => 0, 'share_fail' => 0);
$m->setMulti($items, time() + 360);
} else {
$shareData = $shareData + 1;
$m->set($shareKey, $shareData, 360);
}
}
} else {
if ($method == 'eth_getWork') {
$null = null;
$shareCheckerKey = 'submiting_' . $payout_addr . '_' . $hash_rate;
$data_multi = array('blockinfo' => 'blockinfo', 'eth_getWork_response' => 'eth_getWork_response', $shareCheckerKey => $shareCheckerKey);
$keys = array_keys($data_multi);
$got = $m->getMulti($keys, $null);
while (!$got) {
usleep(100000);
$got = $m->getMulti($keys, $null);
}
$result1 = $got["blockinfo"];
$result = $got["eth_getWork_response"];
$key_Key = $shareCheckerKey;
$CheckShareData = $got[$key_Key];
//$result1 = $m->get('blockinfo');
$block_info_last = json_decode($result1, true);
$last_block_result = $block_info_last['result'];
$last_block_diff = $last_block_result['difficulty'];
$last_block_timestamp = new Math_BigInteger(hexdec($last_block_result['timestamp']));
$current_time = new Math_BigInteger(time());
$lastBlockTime_BI = $current_time->subtract($last_block_timestamp);
public function testGetMultiUnexpectedValue()
{
$request = new MemcacheGetRequest();
$request->addKey("key");
$request->addKey("key1");
$request->setForCas(true);
$response = new MemcacheGetResponse();
$item = $response->addItem();
$item->setKey("key");
$item->setValue("value");
$item->setFlags(2);
// Python's picked type.
$item->setCasId(123456);
$item = $response->addItem();
$item->setKey("key1");
$item->setValue("value1");
$item->setFlags(0);
// String.
$item->setCasId(789);
$this->apiProxyMock->expectCall('memcache', 'Get', $request, $response);
$memcached = new Memcached();
$keys = ["key", "key1"];
$result = $memcached->getMulti($keys, $cas_tokens, Memcached::GET_PRESERVE_ORDER);
$this->assertTrue(array_key_exists("key", $result));
$this->assertNull($result["key"]);
$this->assertTrue(array_key_exists("key", $cas_tokens));
$this->assertNull($cas_tokens["key"]);
$this->assertEquals("value1", $result["key1"]);
$this->assertEquals(789, $cas_tokens["key1"]);
$this->assertEquals($memcached->getResultCode(), Memcached::RES_SUCCESS);
$this->apiProxyMock->verify();
}
/**
* 获取指定键名序列的数据
*
* @param array $keys
* @return array
*/
public function getMulti($keys)
{
return $this->memcached ? $this->memcached->getMulti($keys) : null;
}
