libmemcached Get Functions

The libmemcached functions provide both direct access to a single item, and a multiple-key request mechanism that provides much faster responses when fetching a large number of keys simultaneously.

The main get-style function, which is equivalent to the generic get() is memcached_get(). This function returns a string pointer, pointing to the value associated with the specified key.

char *memcached_get (memcached_st *ptr,
 const char *key, size_t key_length,
 size_t *value_length,
 uint32_t *flags,
 memcached_return *error);

A multi-key get, memcached_mget(), is also available. Using a multiple key get operation is much quicker to do in one block than retrieving the key values with individual calls to memcached_get(). To start the multi-key get, call memcached_mget():

memcached_return
 memcached_mget (memcached_st *ptr,
 char **keys, size_t *key_length,
 unsigned int number_of_keys);

The return value is the success of the operation. The keys parameter should be an array of strings containing the keys, and key_length an array containing the length of each corresponding key. number_of_keys is the number of keys supplied in the array.

To fetch the individual values, use memcached_fetch() to get each corresponding value.

char *memcached_fetch (memcached_st *ptr,
 const char *key, size_t *key_length,
 size_t *value_length,
 uint32_t *flags,
 memcached_return *error);

The function returns the key value, with the key, key_length and value_length parameters being populated with the corresponding key and length information. The function returns NULL when there are no more values to be returned. A full example, including the populating of the key data and the return of the information is provided here.

#include <stdio.h>
#include <sstring.h>
#include <unistd.h>
#include <libmemcached/memcached.h>
int main(int argc, char *argv[])
{
 memcached_server_st *servers = NULL;
 memcached_st *memc;
 memcached_return rc;
 char *keys[]= {'huey', 'dewey', 'louie'};
 size_t key_length[3];
 char *values[]= {'red', 'blue', 'green'};
 size_t value_length[3];
 unsigned int x;
 uint32_t flags;
 char return_key[MEMCACHED_MAX_KEY];
 size_t return_key_length;
 char *return_value;
 size_t return_value_length;
 memc= memcached_create(NULL);
 servers= memcached_server_list_append(servers, 'localhost', 11211, &rc);
 rc= memcached_server_push(memc, servers);
 if (rc == MEMCACHED_SUCCESS)
 fprintf(stderr,'Added server successfully\n');
 else
 fprintf(stderr,'Couldn't add server: %s\n',memcached_strerror(memc, rc));
 for(x= 0; x < 3; x++)
 {
 key_length[x] = strlen(keys[x]);
 value_length[x] = strlen(values[x]);
 rc= memcached_set(memc, keys[x], key_length[x], values[x],
 value_length[x], (time_t)0, (uint32_t)0);
 if (rc == MEMCACHED_SUCCESS)
 fprintf(stderr,'Key %s stored successfully\n',keys[x]);
 else
 fprintf(stderr,'Couldn't store key: %s\n',memcached_strerror(memc, rc));
 }
 rc= memcached_mget(memc, keys, key_length, 3);
 if (rc == MEMCACHED_SUCCESS)
 {
 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
 &return_value_length, &flags, &rc)) != NULL)
 {
 if (rc == MEMCACHED_SUCCESS)
 {
 fprintf(stderr,'Key %s returned %s\n',return_key, return_value);
 }
 }
 }
 return 0;
}

Running the above application produces the following output:

Retornar