Memcache::set

(PECL memcache >= 0.2.0)

Memcache::set — Armazena dados no servidor

Descrição

Memcache::set(
    string $key,
    mixed $var,
    int $flag = ?,
    int $expire = ?
): bool

Memcache::set() armazena um item var com a chave key no servidor memcached. O parâmetro expire é o tempo de expiração em segundos. Se for 0, o item nunca expira (mas o servidor memcached não garante que este item seja armazenado o tempo todo, ele pode ser excluído do cache para dar lugar a outros itens). A constante MEMCACHE_COMPRESSED pode ser usada como valor flag se a intenção for usar a compactação em tempo real (usa zlib).

Nota:
Lembre-se de que variáveis de recursos (por exemplo, descritores de arquivo e conexão) não podem ser armazenadas no cache, porque não podem ser adequadamente representadas no estado serializado.

Também pode ser usada a função memcache_set().

Parâmetros

key: A chave que será associada ao item.
var: A variável a ser armazenada. Strings e inteiros são armazenados diretamente, outros tipos são armazenados serializados.
flag: Use MEMCACHE_COMPRESSED para armazenar o item compactado (usa zlib).
expire: Tempo de expiração do item. Se for igual a zero, o item nunca irá expirar. Você também pode usar o timestamp Unix ou um número de segundos iniciando do horário atual, mas no último caso o número de segundos não pode exceder 2592000 (30 dias).

Valor Retornado

Retorna true em caso de sucesso ou false em caso de falha.

Exemplos

Exemplo #1 Exemplo de Memcache::set()

<?php
/* API procedural */

/* Conecta ao servidor memcached */
$memcache_obj = memcache_connect('memcache_host', 11211);

/*
Define o valor do item com chave 'chave_var'
usando 0 como o valor do parâmetro 'flag', compressão não é usada,
tempo de expiração é de 30 segundos
*/
memcache_set($memcache_obj, 'chave_var', 'variável qualquer', 0, 30);

echo memcache_get($memcache_obj, 'chave_var');

?>

Exemplo #2 Exemplo de Memcache::set()

<?php
/* API orientada a objeto */

$memcache_obj = new Memcache;

/* Conecta ao servidor memcached */
$memcache_obj->connect('memcache_host', 11211);

/*
Define o valor do item com chave 'chave_var', usand compressão em tempo real,
tempo de expiração é de 50 segundos
*/
$memcache_obj->set('chave_var', 'alguma variável realmente grande', MEMCACHE_COMPRESSED, 50);

echo $memcache_obj->get('chave_var');

?>

Veja Também

Memcache::add() - Adiciona um item ao servidor
Memcache::replace() - Substitui o valor do item existente

Melhore Esta Página

Aprenda Como Melhorar Esta Página • Envie uma Solicitação de Modificação • Reporte um Problema

＋adicione uma nota

Notas Enviadas por Usuários (em inglês) 9 notes

down

Sc00bz ¶

17 years ago

This is just two minor things about memcache that might not be perfectly clear, the limits on key and data sizes and what happen to flags in the memcache protocol.



* There is a max key size of 250 anything bigger gets truncated. There is also a (1MB - 42 bytes) limit on the data.



* In the memcache protocol there is a 16bit, 32bit in newer version, flag that you can set to whatever you want because memcache doesn't do anything with the flags. The php api doesn't let you get the flags because php uses the flags for php's own use such as "MEMCACHE_COMPRESSED" and I decided to test if it was doing something because it wasn't part of the memcache protocol.



<?php

$memcache = new Memcache();

$memcache->connect("127.0.0.1", 11211);



// Since memcache truncates the keys at 250 bytes both the get "250 a's" and "251 a's" will find the key in the cache

echo "*** Truncate key test ***<br>";

echo "set 251: " . ($memcache->set(str_repeat("a", 251), "value", 0, 1) ? "t" : "f") . "<br>";



echo "get 249: " . (($ret = $memcache->get(str_repeat("a", 249))) !== false ? "'$ret'" : "f") . "<br>";

echo "get 250: " . (($ret = $memcache->get(str_repeat("a", 250))) !== false ? "'$ret'" : "f") . "<br>";

echo "get 251: " . (($ret = $memcache->get(str_repeat("a", 251))) !== false ? "'$ret'" : "f") . "<br>";

echo "delete: " . ($memcache->delete(str_repeat("a", 250)) ? "t" : "f") . "<br><br>";



echo "*** Compress value test ***<br>";

echo "set 1024*1024-42: " . ($memcache->set("test", str_repeat("a", 1024*1024-42), 0, 1) ? "t" : "f") . "<br>";

echo "set 1024*1024-41: " . ($memcache->set("test", str_repeat("a", 1024*1024-41), 0, 1) ? "t" : "f") . "<br>";

echo "set 1024*1024 compressed: " . ($memcache->set("test", str_repeat("a", 1024*1024), MEMCACHE_COMPRESSED, 1) ? "t" : "f") . "<br>";

echo "delete: " . ($memcache->delete("test") ? "t" : "f") . "<br>";

$memcache->close();

?>



Output:

*** Truncate key test ***

set 251: t

get 249: f

get 250: 'value'

get 251: 'value'

delete: t



*** Compress value test ***

set 1024*1024-42: t

set 1024*1024-41: f

set 1024*1024 compressed: t

delete: t

down

wbonde at yakabod dot com ¶

14 years ago

The max time for expiration (without having to worry about deletions when necessary as with 0 seconds) is 2,592,000 seconds (30 days). 

Specifying an expiration value above that will return false, but will NOT throw in error so it is easy to miss.

down

argyleblanket ¶

16 years ago

Using set more than once for the same key seems to have unexpected results - it does not behave as a "replace," but instead seems to "set" more than one value for the same key.  "get" may return any of the values.



This was tested on a multiple-server setup - behaviour may be different if you only have one server.



Remedy is to use a combination of replace and set:



<?php

$result = $memcache->replace( $key, $var );

if( $result == false )

{

    $result = $memcache->set( $key, $var );

}

?>

down

Stephen from veedow.com ¶

17 years ago

I ran into problems using the MEMCACHE_COMPRESSED flag when storing small amounts of data, such as an integers.



For expample.



<?php

Memcache::set('integer', 123456, MEMCACHE_COMPRESSED);

//would return true



Memcache::get('integer');

//would return false

?>



This problem went away when I removed the MEMCACHE_COMPRESSED flag for values that were small.

down

duerra at nospam dot yahoo dot com ¶

14 years ago

If you're interested in using compression, please note that, at least for PHP version 5.3.2 and Memcache version 3.0.4, when retrieving a key who's value is a numeric or boolean type, PHP throws a notice of the following:

Message: MemcachePool::get(): Failed to uncompress data

The way around this is to test your variable type before setting or adding it to Memcache, or even cast it as a string.  

<?php
$key = 'mc_key';
$value = 12345;
$compress = is_bool($value) || is_int($value) || is_float($value) ? false : MEMCACHE_COMPRESSED;

$mc= new Memcache;
$mc->connect('localhost', 11211);
$mc->set($key, $value, $compress);

echo $mc->get($key);

//Alternative is to cast the variable
$value = is_scalar($value) ? (string)$value : $value;
$mc->set($key, $value, MEMCACHE_COMPRESSED);
?>

down

winmutt ¶

5 years ago

The note here about replace and set is no longer valid in my testing. You can call set as many times as you want on the same key and reliably get the last written value. I tested this with 3 memcache nodes over 10000 keys.

down

jcastromail at yahoo dot es ¶

7 years ago

If you get the next message

"The lowest two bytes of the flags array is reserved for pecl/memcache internal use"

Then try the next operations:
a) try to use Memcached instead of Memcache.
b) switch the compressed value
  $memcache->set($key,$value,MEMCACHE_COMPRESSED)
  or
  $memcache->set($key,$value,0)

down

-1

effeesse gmail com ¶

14 years ago

if you want to cache an image created on-the-fly you can do:



<?php

ob_start();

imagepng($image);

$memcache->set("my_image", ob_get_contents(), false, $cache_time);

ob_end_clean();

?>



then you could access the chached image as simple variable:

<?php $my_image = $memcache->get("my_image"); ?>



so, in short, you have to buffer the output

down

-4

aamthor at advertzoom dot de ¶

12 years ago

to put some things right:

max expiration time: RTFM, it's written here.

max amount of data: almost unlimited as long as your server can bear it.

speed and pace: 
well, thats another thing. We had a couple of data records which for application reasons must be kept in memory. Since the bunch of data is big and doesn't change very often, we considered caching it to memcache instead of retrieving it from the DB each and every time.

This isn't a general advice nor any quality statement, but we did a couple of tests with serialized arrays (50 MB), compressed and uncompressed and it turned out that in our particular scenario, memcache is much slower than the DB (mySql).

In general, one can not predict on the behavior of memcache in certain scenarios but always need to make some testing and benchmarking upfront before starting to deploy things to a live system.

Despite of the tests above, we are still using memcache for session caching instead of file system, since there are certain other things to consider and the amount of data is always small (few KB)

＋adicione uma nota