Merge Trond

diff --git a/clients/execute.c b/clients/execute.c
index e25483392e2876e51b61b202c684a437bd23f423..7255d37ede3522dcc15a97a239aed387c898d1fb 100644 (file)
--- a/clients/execute.c
+++ b/clients/execute.c
@@ -46,7 +46,7 @@ unsigned int execute_get(memcached_st *memc, pairs_st *pairs, unsigned int numbe
     uint32_t flags;
     unsigned int fetch_key;
 
-    fetch_key= (unsigned int)random() % number_of;
+    fetch_key= (unsigned int)((unsigned int)random() % number_of);
 
     value= memcached_get(memc, pairs[fetch_key].key, pairs[fetch_key].key_length,
                          &value_length, &flags, &rc);

diff --git a/clients/generator.c b/clients/generator.c
index 213246ba2206a3d84916c8503c43c089bc26e975..5bce0301ab6ae848f9315ea5b85c186210c8f30a 100644 (file)
--- a/clients/generator.c
+++ b/clients/generator.c
@@ -47,7 +47,9 @@ void pairs_free(pairs_st *pairs)
 pairs_st *pairs_generate(uint64_t number_of, size_t value_length)
 {
   unsigned int x;
-  pairs_st *pairs= calloc((size_t)(number_of + 1), sizeof(pairs_st));
+  pairs_st *pairs;
+
+  pairs= (pairs_st*)calloc((size_t)number_of + 1, sizeof(pairs_st));
 
   if (!pairs)
     goto error;

diff --git a/clients/memstat.c b/clients/memstat.c
index e6783b68c095c7a8de4b2f88309a2ce5f53aceed..847e7f0d0ee8eeb8763ca07158a34705ff67e57e 100644 (file)
--- a/clients/memstat.c
+++ b/clients/memstat.c
@@ -168,8 +168,8 @@ static void run_analyzer(memcached_st *memc, memcached_stat_st *memc_stat,
       }
       gettimeofday(&end_time, NULL);
 
-      elapsed_time= timedif(end_time, start_time);
-      elapsed_time /= (long)num_of_tests;
+      elapsed_time= (long) timedif(end_time, start_time);
+      elapsed_time /= (long) num_of_tests;
 
       if (elapsed_time > slowest_time)
       {

diff --git a/libmemcached/memcached_get.c b/libmemcached/memcached_get.c
index ee4f68e7ecb0c006c4025f346340ba0941b41ca6..176be6ad5af2d388b10dc3978c673a409750d7bb 100644 (file)
--- a/libmemcached/memcached_get.c
+++ b/libmemcached/memcached_get.c
@@ -14,6 +14,14 @@ char *memcached_get(memcached_st *ptr, const char *key,
                               flags, error);
 }
 
+static memcached_return memcached_mget_by_key_real(memcached_st *ptr, 
+                                       const char *master_key, 
+                                       size_t master_key_length,
+                                       const char **keys, 
+                                       size_t *key_length, 
+                                       size_t number_of_keys,
+                                      bool mget_mode);
+
 char *memcached_get_by_key(memcached_st *ptr, 
                            const char *master_key, 
                            size_t master_key_length, 
@@ -34,10 +42,10 @@ char *memcached_get_by_key(memcached_st *ptr,
   }
 
   /* Request the key */
-  *error= memcached_mget_by_key(ptr, 
+  *error= memcached_mget_by_key_real(ptr, 
                                 master_key, 
                                 master_key_length, 
-                                (const char **)&key, &key_length, 1);
+                                (const char **)&key, &key_length, 1, false);
 
   value= memcached_fetch(ptr, NULL, NULL, 
                          value_length, flags, error);
@@ -112,14 +120,16 @@ static memcached_return binary_mget_by_key(memcached_st *ptr,
                                            unsigned int master_server_key,
                                            bool is_master_key_set,
                                            const char **keys, size_t *key_length,
-                                           size_t number_of_keys);
+                                           size_t number_of_keys,
+                                          bool mget_mode);
 
-memcached_return memcached_mget_by_key(memcached_st *ptr, 
+static memcached_return memcached_mget_by_key_real(memcached_st *ptr, 
                                        const char *master_key, 
                                        size_t master_key_length,
                                        const char **keys, 
                                        size_t *key_length, 
-                                       size_t number_of_keys)
+                                       size_t number_of_keys,
+                                      bool mget_mode)
 {
   unsigned int x;
   memcached_return rc= MEMCACHED_NOTFOUND;
@@ -173,7 +183,7 @@ memcached_return memcached_mget_by_key(memcached_st *ptr,
   
   if (ptr->flags & MEM_BINARY_PROTOCOL)
     return binary_mget_by_key(ptr, master_server_key, is_master_key_set, keys, 
-                              key_length, number_of_keys);
+                              key_length, number_of_keys, mget_mode);
 
   if (ptr->flags & MEM_SUPPORT_CAS)
   {
@@ -256,11 +266,22 @@ memcached_return memcached_mget_by_key(memcached_st *ptr,
   return rc;
 }
 
+memcached_return memcached_mget_by_key(memcached_st *ptr, 
+                                       const char *master_key, 
+                                       size_t master_key_length,
+                                       const char **keys, 
+                                       size_t *key_length, 
+                                       size_t number_of_keys)
+{
+  return memcached_mget_by_key_real(ptr, master_key, master_key_length, keys, 
+                                    key_length, number_of_keys, true);
+}
+
 static memcached_return simple_binary_mget(memcached_st *ptr,
                                            unsigned int master_server_key,
                                            bool is_master_key_set,
                                            const char **keys, size_t *key_length, 
-                                           size_t number_of_keys)
+                                           size_t number_of_keys, bool mget_mode)
 {
   memcached_return rc= MEMCACHED_NOTFOUND;
   uint32_t x;
@@ -289,10 +310,10 @@ static memcached_return simple_binary_mget(memcached_st *ptr,
      
     protocol_binary_request_getk request= {.bytes= {0}};
     request.message.header.request.magic= PROTOCOL_BINARY_REQ;
-    if (number_of_keys == 1)
-      request.message.header.request.opcode= PROTOCOL_BINARY_CMD_GETK;
-    else
+    if (mget_mode)
       request.message.header.request.opcode= PROTOCOL_BINARY_CMD_GETKQ;
+    else
+      request.message.header.request.opcode= PROTOCOL_BINARY_CMD_GETK;
 
     memcached_return vk;
     vk= memcached_validate_key_length(key_length[x],
@@ -323,7 +344,7 @@ static memcached_return simple_binary_mget(memcached_st *ptr,
       rc= MEMCACHED_SOME_ERRORS;
   }
 
-  if (number_of_keys > 1) 
+  if (mget_mode) 
   {
     /*
      * Send a noop command to flush the buffers
@@ -361,7 +382,7 @@ static memcached_return simple_binary_mget(memcached_st *ptr,
 static memcached_return replication_binary_mget(memcached_st *ptr,
                                              uint32_t* hash, bool* dead_servers,
                                              const char **keys, size_t *key_length,
-                                             size_t number_of_keys)
+                                             size_t number_of_keys, bool mget_mode)
 {
   memcached_return rc= MEMCACHED_NOTFOUND;
   uint32_t x;
@@ -398,10 +419,10 @@ static memcached_return replication_binary_mget(memcached_st *ptr,
 
       protocol_binary_request_getk request= {.bytes= {0}};
       request.message.header.request.magic= PROTOCOL_BINARY_REQ;
-      if (number_of_keys == 1)
-        request.message.header.request.opcode= PROTOCOL_BINARY_CMD_GETK;
-      else
+      if (mget_mode)
         request.message.header.request.opcode= PROTOCOL_BINARY_CMD_GETKQ;
+      else
+        request.message.header.request.opcode= PROTOCOL_BINARY_CMD_GETK;
 
       request.message.header.request.keylen= htons((uint16_t)key_length[x]);
       request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES;
@@ -420,7 +441,7 @@ static memcached_return replication_binary_mget(memcached_st *ptr,
       memcached_server_response_increment(&ptr->hosts[server]);
     }
 
-    if (number_of_keys > 1)
+    if (mget_mode)
     {
       /*
        * Send a noop command to flush the buffers
@@ -460,14 +481,14 @@ static memcached_return binary_mget_by_key(memcached_st *ptr,
                                            unsigned int master_server_key,
                                            bool is_master_key_set,
                                            const char **keys, size_t *key_length,
-                                           size_t number_of_keys)
+                                           size_t number_of_keys, bool mget_mode)
 {
   memcached_return rc;
 
   if (ptr->number_of_replicas == 0) 
   {
     rc= simple_binary_mget(ptr, master_server_key, is_master_key_set,
-                           keys, key_length, number_of_keys);
+                           keys, key_length, number_of_keys, mget_mode);
   } 
   else 
   {
@@ -492,7 +513,7 @@ static memcached_return binary_mget_by_key(memcached_st *ptr,
         hash[x]= memcached_generate_hash(ptr, keys[x], key_length[x]);
 
     rc= replication_binary_mget(ptr, hash, dead_servers, keys, 
-                                key_length, number_of_keys);
+                                key_length, number_of_keys, mget_mode);
 
     ptr->call_free(ptr, hash);
     ptr->call_free(ptr, dead_servers);

diff --git a/tests/function.c b/tests/function.c
index 661c324ee5ba99e490703a2a1f4038724ccea37b..418077717c8856ae51e397b0b9fdc54ab8f55bcc 100644 (file)
--- a/tests/function.c
+++ b/tests/function.c
@@ -1050,6 +1050,70 @@ static test_return get_test5(memcached_st *memc)
   return TEST_SUCCESS;
 }
 
+static test_return  mget_end(memcached_st *memc)
+{
+  const char *keys[]= { "foo", "foo2" };
+  size_t lengths[]= { 3, 4 };
+  const char *values[]= { "fjord", "41" };
+
+  memcached_return rc;
+
+  // Set foo and foo2
+  for (int i= 0; i < 2; i++)
+  {
+    rc= memcached_set(memc, keys[i], lengths[i], values[i], strlen(values[i]),
+                     (time_t)0, (uint32_t)0);
+    assert(rc == MEMCACHED_SUCCESS);
+  }
+
+  char *string;
+  size_t string_length;
+  uint32_t flags;
+
+  // retrieve both via mget
+  rc= memcached_mget(memc, keys, lengths, 2);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  char key[MEMCACHED_MAX_KEY];
+  size_t key_length;
+
+  // this should get both
+  for (int i = 0; i < 2; i++) 
+  {
+    string= memcached_fetch(memc, key, &key_length, &string_length,
+                            &flags, &rc);
+    assert(rc == MEMCACHED_SUCCESS);
+    int val = 0;
+    if (key_length == 4)
+      val= 1;
+    assert(string_length == strlen(values[val]));
+    assert(strncmp(values[val], string, string_length) == 0);
+    free(string);
+  }
+
+  // this should indicate end
+  string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc);
+  assert(rc == MEMCACHED_END);
+
+  // now get just one
+  rc= memcached_mget(memc, keys, lengths, 1);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc);
+  assert(key_length == lengths[0]);
+  assert(strncmp(keys[0], key, key_length) == 0);
+  assert(string_length == strlen(values[0]));
+  assert(strncmp(values[0], string, string_length) == 0);
+  assert(rc == MEMCACHED_SUCCESS);
+  free(string);
+
+  // this should indicate end
+  string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc);
+  assert(rc == MEMCACHED_END);
+
+  return TEST_SUCCESS;
+}
+
 /* Do not copy the style of this code, I just access hosts to testthis function */
 static test_return  stats_servername_test(memcached_st *memc)
 {
@@ -4477,6 +4541,7 @@ test_st tests[] ={
   {"mget_result", 1, mget_result_test },
   {"mget_result_alloc", 1, mget_result_alloc_test },
   {"mget_result_function", 1, mget_result_function },
+  {"mget_end", 0, mget_end },
   {"get_stats", 0, get_stats },
   {"add_host_test", 0, add_host_test },
   {"add_host_test_1", 0, add_host_test1 },