git.m6w6.name Git - awesomized/libmemcached/blob - clients/execute.c

   1 /*
   2   Execute a memcached_set() a set of pairs.
   3   Return the number of rows set.
   4 */
   5
   6 #include "libmemcached/common.h"
   7
   8 #include "execute.h"
   9
  10 unsigned int execute_set(memcached_st *memc, pairs_st *pairs, unsigned int number_of)
  11 {
  12   memcached_return rc;
  13   unsigned int x;
  14   unsigned int pairs_sent;
  15
  16   for (x= 0, pairs_sent= 0; x < number_of; x++)
  17   {
  18     rc= memcached_set(memc, pairs[x].key, pairs[x].key_length,
  19                       pairs[x].value, pairs[x].value_length,
  20                       0, 0);
  21     if (rc != MEMCACHED_SUCCESS && rc != MEMCACHED_BUFFERED)
  22       fprintf(stderr, "Failured on insert of %.*s\n",
  23               (unsigned int)pairs[x].key_length, pairs[x].key);
  24     else
  25       pairs_sent++;
  26   }
  27
  28   return pairs_sent;
  29 }
  30
  31 /*
  32   Execute a memcached_get() on a set of pairs.
  33   Return the number of rows retrieved.
  34 */
  35 unsigned int execute_get(memcached_st *memc, pairs_st *pairs, unsigned int number_of)
  36 {
  37   memcached_return rc;
  38   unsigned int x;
  39   unsigned int retrieved;
  40
  41
  42   for (retrieved= 0,x= 0; x < number_of; x++)
  43   {
  44     char *value;
  45     size_t value_length;
  46     uint32_t flags;
  47     unsigned int fetch_key;
  48
  49     fetch_key= (unsigned int)((unsigned int)random() % number_of);
  50
  51     value= memcached_get(memc, pairs[fetch_key].key, pairs[fetch_key].key_length,
  52                          &value_length, &flags, &rc);
  53
  54     if (rc != MEMCACHED_SUCCESS)
  55       fprintf(stderr, "Failured on read of %.*s\n",
  56               (unsigned int)pairs[fetch_key].key_length, pairs[fetch_key].key);
  57     else
  58       retrieved++;
  59
  60     free(value);
  61   }
  62
  63   return retrieved;
  64 }
  65
  66 /**
  67  * Callback function to count the number of results
  68  */
  69 static memcached_return callback_counter(memcached_st *ptr,
  70                                          memcached_result_st *result,
  71                                          void *context)
  72 {
  73   (void)ptr;
  74   (void)result;
  75   unsigned int *counter= (unsigned int *)context;
  76   *counter= *counter + 1;
  77
  78   return MEMCACHED_SUCCESS;
  79 }
  80
  81 /**
  82  * Try to run a large mget to get all of the keys
  83  * @param memc memcached handle
  84  * @param keys the keys to get
  85  * @param key_length the length of the keys
  86  * @param number_of the number of keys to try to get
  87  * @return the number of keys received
  88  */
  89 unsigned int execute_mget(memcached_st *memc,
  90                           const char * const *keys,
  91                           size_t *key_length,
  92                           unsigned int number_of)
  93 {
  94   unsigned int retrieved= 0;
  95   memcached_execute_function callbacks[1]= { [0]= &callback_counter };
  96   memcached_return rc;
  97   rc= memcached_mget_execute(memc, keys, key_length,
  98                              (size_t)number_of, callbacks, &retrieved, 1);
  99
 100   likely (rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOTFOUND ||
 101           rc == MEMCACHED_BUFFERED || rc == MEMCACHED_END)
 102   {
 103     rc= memcached_fetch_execute(memc, callbacks, (void *)&retrieved, 1);
 104     unlikely (rc != MEMCACHED_SUCCESS && rc != MEMCACHED_NOTFOUND &&
 105               rc != MEMCACHED_END)
 106     {
 107       fprintf(stderr, "Failed to execute mget: %s\n",
 108               memcached_strerror(memc, rc));
 109       memcached_quit(memc);
 110       return 0;
 111     }
 112   }
 113   else
 114   {
 115     fprintf(stderr, "Failed to execute mget: %s\n",
 116             memcached_strerror(memc, rc));
 117     memcached_quit(memc);
 118     return 0;
 119   }
 120
 121   return retrieved;
 122 }