memcached 0.19.10 → 0.20.0

data/CHANGELOG

@@ -1,4 +1,6 @@
 
+v0.20.0. Add experimental module, with get_len() operator.
+
 v0.19.10. Add no-op hash (MEMCACHED_HASH_NONE) to skip hashing when there is one server (bierbaum). Updated benchmark.
 
 v0.19.8. Support :noreply behavior.

data/Manifest

@@ -10,6 +10,7 @@ ext/libmemcached-0.32.tar.gz
 ext/libmemcached-2.patch
 ext/libmemcached-3.patch
 ext/libmemcached-4.patch
+ext/libmemcached-5.patch
 ext/libmemcached.patch
 ext/rlibmemcached.i
 ext/rlibmemcached_wrap.c
@@ -18,6 +19,7 @@ lib/memcached.rb
 lib/memcached/auth.rb
 lib/memcached/behaviors.rb
 lib/memcached/exceptions.rb
+lib/memcached/experimental_memcached.rb
 lib/memcached/integer.rb
 lib/memcached/memcached.rb
 lib/memcached/rails.rb
@@ -28,5 +30,6 @@ test/setup.rb
 test/teardown.rb
 test/test_helper.rb
 test/unit/binding_test.rb
+test/unit/memcached_experimental_test.rb
 test/unit/memcached_test.rb
 test/unit/rails_test.rb

data/ext/extconf.rb

@@ -67,6 +67,10 @@ def check_libmemcached
       puts(cmd = "#{patch} -p1 -Z < libmemcached-4.patch")
       raise "'#{cmd}' failed" unless system(cmd) or ENV['DEV']
 
+      puts "Patching libmemcached for get_len command."
+      puts(cmd = "#{patch} -p1 -Z < libmemcached-5.patch")
+      raise "'#{cmd}' failed" unless system(cmd) or ENV['DEV']
+
       puts "Touching aclocal.m4  in libmemcached."
       puts(cmd = "touch -r #{BUNDLE_PATH}/m4/visibility.m4 #{BUNDLE_PATH}/configure.ac #{BUNDLE_PATH}/m4/pandora_have_sasl.m4")
       raise "'#{cmd}' failed" unless system(cmd)

data/ext/libmemcached-5.patch

@@ -0,0 +1,832 @@
+diff --git a/docs/memcached_get.pod b/docs/memcached_get.pod
+--- a/libmemcached-0.32/docs/memcached_get.pod
++++ b/docs/memcached_get.pod
+@@ -1,6 +1,6 @@
+ =head1 NAME
+ 
+-memcached_get, memcached_mget, memcached_fetch - Get a value
++memcached_get, memcached_get_len, memcached_mget, memcached_mget_len, memcached_fetch - Get a value
+ 
+ =head1 LIBRARY
+ 
+@@ -15,20 +15,21 @@ C Client Library for memcached (libmemcached, -lmemcached)
+ 		       memcached_result_st *result,
+ 		       memcached_return *error);
+ 
+-  char *memcached_get (memcached_st *ptr,
+-                       const char *key, size_t key_length,
+-                       size_t *value_length, 
+-                       uint32_t *flags,
+-                       memcached_return *error);
++  char *memcached_get(memcached_st *ptr,
++                      const char *key, size_t key_length,
++                      size_t *value_length, 
++                      uint32_t *flags,
++                      memcached_return *error);
+ 
+   memcached_return
+-  memcached_mget (memcached_st *ptr, 
+-                  char **keys, size_t *key_length, 
+-                  size_t number_of_keys);
++  memcached_mget(memcached_st *ptr, 
++                 char **keys, size_t *key_length, 
++                 size_t number_of_keys);
+   char *
+   memcached_get_by_key(memcached_st *ptr, 
+                        const char *master_key, size_t master_key_length, 
+                        const char *key, size_t key_length, 
++                       uint32_t user_spec_len,
+                        size_t *value_length, 
+                        uint32_t *flags,
+                        memcached_return *error);
+@@ -37,19 +38,33 @@ C Client Library for memcached (libmemcached, -lmemcached)
+   memcached_mget_by_key(memcached_st *ptr, 
+                         const char *master_key, size_t master_key_length,
+                         char **keys, size_t *key_length, 
+-                        size_t number_of_keys);
+-
+-  char *memcached_fetch (memcached_st *ptr,
+-                         char *key, size_t *key_length, 
+-                         size_t *value_length,
+-                         uint32_t *flags, 
+-                         memcached_return *error);
++                        size_t number_of_keys,
++                       uint32_t user_spec_len);
++
++  char *memcached_fetch(memcached_st *ptr,
++                        char *key, size_t *key_length, 
++                        size_t *value_length,
++                        uint32_t *flags, 
++                        memcached_return *error);
+   memcached_return 
+   memcached_fetch_execute(memcached_st *ptr, 
+                           memcached_return (*callback[])(memcached_st *ptr, memcached_result_st *result, void *context),
+                           void *context,
+                           unsigned int number_of_callbacks);
+ 
++  char *
++  memcached_get_len(memcached_st *ptr, 
++                    const char *key, size_t key_length,
++                    uint32_t user_spec_len,
++                    size_t *value_length, 
++                    uint32_t *flags,
++                    memcached_return *error);
++
++  memcached_return
++  memcached_mget_len(memcached_st *ptr, 
++                     const char **keys, size_t *key_length, 
++                     size_t number_of_keys, uint32_t user_spec_len);
++
+ =head1 DESCRIPTION
+ 
+ memcached_get() is used to fetch an individual value from the server. You
+@@ -61,6 +76,12 @@ memcached_return pointer to hold any error. The object will be returned
+ upon success and NULL will be returned on failure. Any object returned by
+ memcached_get() must be released by the caller application. 
+ 
++memcached_get_len() is also used to fetch an individual value from the
++server.  The only difference when compared to memcached_get() is that
++the server will only send back the first n bytes of the value where n is
++specified by the user.  Note that this command is only available when
++using the ascii protocol.
++
+ memcached_mget() is used to select multiple keys at once. For multiple key
+ operations it is always faster to use this function. This function always
+ works asynchronously. memcached_fetch() is then used to retrieve any keys
+@@ -71,17 +92,23 @@ return NULL (aka no more values). If you need to quit in the middle of a
+ memcached_get() call, execute a memcached_quit(). After you do this, you can
+ issue new queries against the server.
+ 
++memcached_mget_len() is also used to select multiple keys at once.  The
++only difference when compared to memcached_mget() is that the server
++will only send back the first n bytes of each value where n is
++specified by the user.  Note that this command is only available when
++using the ascii protocol.
++
+ memcached_fetch() is used to fetch an individual value from the server. 
+-memcached_mget() must always be called before using this method.  You
+-must pass in a key and its length to fetch the object. You must supply
+-three pointer variables which will give you the state of the returned
+-object.  A uint32_t pointer to contain whatever flags you stored with the value,
+-a size_t pointer which will be filled with size of of the object, and a
+-memcached_return pointer to hold any error. The object will be returned
+-upon success and NULL will be returned on failure. MEMCACHD_END is returned
+-by the *error value when all objects that have been found are returned. 
+-The final value upon MEMCACHED_END is null. Values returned by
+-memcached_fetch() musted be free'ed by the caller.
++memcached_mget() or memcached_mget_len() must always be called before
++using this method.  You must pass in a key and its length to fetch the
++object. You must supply three pointer variables which will give you the
++state of the returned object.  A uint32_t pointer to contain whatever
++flags you stored with the value, a size_t pointer which will be filled
++with size of of the object, and a memcached_return pointer to hold any
++error. The object will be returned upon success and NULL will be returned
++on failure. MEMCACHD_END is returned by the *error value when all objects
++that have been found are returned.  The final value upon MEMCACHED_END is
++null. Values returned by memcached_fetch() musted be free'ed by the caller.
+ 
+ memcached_fetch_result() is used to return a memcached_result_st(3) structure 
+ from a memcached server. The result object is forward compatible with changes
+@@ -113,8 +140,9 @@ C<MEMCACHED_NOT_SUPPORTED>.
+ =head1 RETURN
+ 
+ All objects returned must be freed by the calling application.
+-memcached_get() and memcached_fetch() will return NULL on error. You must
+-look at the value of error to determine what the actual error was.
++memcached_get(), memcached_get_len(), and memcached_fetch() will return
++NULL on error. You must look at the value of error to determine what
++the actual error was.
+ 
+ =head1 HOME
+ 
+diff --git a/libmemcached/common.h b/libmemcached/common.h
+--- a/libmemcached-0.32/libmemcached/common.h
++++ b/libmemcached/libmemcached/common.h
+@@ -34,6 +34,15 @@
+ # endif
+ #endif
+ 
++/* Note we need the 2 concats below because arguments to ##
++ * are not expanded, so we need to expand __LINE__ with one indirection
++ * before doing the actual concatenation.
++ * From: http://www.pixelbeat.org/programming/gcc/static_assert.html
++ */
++#define ASSERT_CONCAT_(a, b) a##b
++#define ASSERT_CONCAT(a, b) ASSERT_CONCAT_(a, b)
++#define assert_on_compile(e) enum { ASSERT_CONCAT(assert_line_, __LINE__) = 1/(!!(e)) }
++
+ /* Define this here, which will turn on the visibilty controls while we're
+  * building libmemcached.
+  */
+diff --git a/libmemcached/memcached.hpp b/libmemcached/memcached.hpp
+--- a/libmemcached-0.32/libmemcached/memcached.hpp
++++ b/libmemcached/libmemcached/memcached.hpp
+@@ -175,6 +175,7 @@ public:
+     char *value= memcached_get_by_key(&memc, 
+                                       master_key.c_str(), master_key.length(), 
+                                       key.c_str(), key.length(),
++                                      GET_LEN_ARG_UNSPECIFIED,
+                                       &value_length, &flags, &rc);
+     if (value)
+     {
+diff --git a/libmemcached/memcached_get.c b/libmemcached/memcached_get.c
+--- a/libmemcached-0.32/libmemcached/memcached_get.c
++++ b/libmemcached/libmemcached/memcached_get.c
+@@ -10,14 +10,29 @@ char *memcached_get(memcached_st *ptr, const char *key,
+                     uint32_t *flags,
+                     memcached_return *error)
+ {
+-  return memcached_get_by_key(ptr, NULL, 0, key, key_length, value_length, 
++  return memcached_get_by_key(ptr, NULL, 0, key, key_length,
++                              GET_LEN_ARG_UNSPECIFIED, value_length,
+                               flags, error);
+ }
+ 
++char *memcached_get_len(memcached_st *ptr, 
++                        const char *key, size_t key_length,
++                        uint32_t user_spec_len,
++                        size_t *value_length, 
++                        uint32_t *flags,
++                        memcached_return *error)
++{
++  return memcached_get_by_key(ptr, NULL, 0, key, key_length,
++                              user_spec_len, value_length, 
++                              flags, error);
++
++}
++
+ char *memcached_get_by_key(memcached_st *ptr, 
+                            const char *master_key, 
+                            size_t master_key_length, 
+                            const char *key, size_t key_length,
++                           uint32_t user_spec_len,
+                            size_t *value_length, 
+                            uint32_t *flags,
+                            memcached_return *error)
+@@ -37,7 +52,8 @@ char *memcached_get_by_key(memcached_st *ptr,
+   *error= memcached_mget_by_key(ptr, 
+                                 master_key, 
+                                 master_key_length, 
+-                                (const char **)&key, &key_length, 1);
++                                (const char **)&key, &key_length, 1,
++                                user_spec_len);
+ 
+   value= memcached_fetch(ptr, NULL, NULL, 
+                          value_length, flags, error);
+@@ -105,7 +121,16 @@ memcached_return memcached_mget(memcached_st *ptr,
+                                 const char **keys, size_t *key_length, 
+                                 size_t number_of_keys)
+ {
+-  return memcached_mget_by_key(ptr, NULL, 0, keys, key_length, number_of_keys);
++  return memcached_mget_by_key(ptr, NULL, 0, keys, key_length, number_of_keys,
++                               GET_LEN_ARG_UNSPECIFIED);
++}
++
++memcached_return memcached_mget_len(memcached_st *ptr, 
++                                    const char **keys, size_t *key_length, 
++                                    size_t number_of_keys, uint32_t user_spec_len)
++{
++  return memcached_mget_by_key(ptr, NULL, 0, keys, key_length, number_of_keys,
++                               user_spec_len);
+ }
+ 
+ static memcached_return binary_mget_by_key(memcached_st *ptr,
+@@ -114,19 +139,28 @@ static memcached_return binary_mget_by_key(memcached_st *ptr,
+                                            const char **keys, size_t *key_length,
+                                            size_t number_of_keys);
+ 
++static bool user_specified_length_is_valid(uint32_t user_spec_len)
++{
++  assert_on_compile(GET_LEN_ARG_UNSPECIFIED == -1U);
++  return (user_spec_len > 0 && user_spec_len < GET_LEN_ARG_UNSPECIFIED);
++}
++
+ 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)
++                                       size_t number_of_keys,
++                                       uint32_t user_spec_len)
+ {
+   unsigned int x;
++  const char *get_command;
++  uint8_t get_command_length;
+   memcached_return rc= MEMCACHED_NOTFOUND;
+-  const char *get_command= "get ";
+-  uint8_t get_command_length= 4;
+   unsigned int master_server_key= (unsigned int)-1; /* 0 is a valid server id! */
+   bool is_master_key_set= false;
++  bool use_cas = (ptr->flags & MEM_SUPPORT_CAS);
++  bool length_specified = (user_spec_len != GET_LEN_ARG_UNSPECIFIED);
+ 
+    unlikely (ptr->flags & MEM_USE_UDP)
+     return MEMCACHED_NOT_SUPPORTED;
+@@ -151,6 +185,14 @@ memcached_return memcached_mget_by_key(memcached_st *ptr,
+     is_master_key_set= true;
+   }
+ 
++  if (length_specified) {
++    if (ptr->flags & MEM_BINARY_PROTOCOL)
++      return MEMCACHED_NOT_SUPPORTED;
++
++    if (!user_specified_length_is_valid(user_spec_len))
++      return MEMCACHED_FAILURE;
++  }
++
+   /* 
+     Here is where we pay for the non-block API. We need to remove any data sitting
+     in the queue before we start our get.
+@@ -175,10 +217,24 @@ memcached_return memcached_mget_by_key(memcached_st *ptr,
+     return binary_mget_by_key(ptr, master_server_key, is_master_key_set, keys, 
+                               key_length, number_of_keys);
+ 
+-  if (ptr->flags & MEM_SUPPORT_CAS)
+-  {
+-    get_command= "gets ";
+-    get_command_length= 5;
++  if (length_specified) {
++    if (use_cas) 
++    {
++      get_command= "gets_len ";
++      get_command_length= 9;
++    } else {
++      get_command= "get_len ";
++      get_command_length= 8;
++    }
++  } else {
++    if (use_cas) 
++    {
++      get_command= "gets ";
++      get_command_length= 5;
++    } else {
++      get_command= "get ";
++      get_command_length= 4;
++    }
+   }
+ 
+   /* 
+@@ -206,6 +262,17 @@ memcached_return memcached_mget_by_key(memcached_st *ptr,
+         rc= MEMCACHED_SOME_ERRORS;
+         continue;
+       }
++
++      if (length_specified) {
++        char len[GET_LEN_BUFSZ];
++        if (snprintf(len, GET_LEN_BUFSZ, "%d ", user_spec_len) < 0 ||
++          (memcached_io_write(&ptr->hosts[server_key], len, strlen(len), 0) == -1))
++        {
++          rc= MEMCACHED_SOME_ERRORS;
++          continue;
++        }
++      }
++
+       WATCHPOINT_ASSERT(ptr->hosts[server_key].cursor_active == 0);
+       memcached_server_response_increment(&ptr->hosts[server_key]);
+       WATCHPOINT_ASSERT(ptr->hosts[server_key].cursor_active == 1);
+diff --git a/libmemcached/memcached_get.h b/libmemcached/memcached_get.h
+--- a/libmemcached-0.32/libmemcached/memcached_get.h
++++ b/libmemcached/libmemcached/memcached_get.h
+@@ -13,6 +13,9 @@
+ extern "C" {
+ #endif
+ 
++#define GET_LEN_ARG_UNSPECIFIED -1U
++#define GET_LEN_BUFSZ 32
++
+ /* Public defines */
+ LIBMEMCACHED_API
+ char *memcached_get(memcached_st *ptr, 
+@@ -22,14 +25,29 @@ char *memcached_get(memcached_st *ptr,
+                     memcached_return *error);
+ 
+ LIBMEMCACHED_API
++char *memcached_get_len(memcached_st *ptr, 
++                        const char *key, size_t key_length,
++                        uint32_t user_spec_len,
++                        size_t *value_length, 
++                        uint32_t *flags,
++                        memcached_return *error);
++
++LIBMEMCACHED_API
+ memcached_return memcached_mget(memcached_st *ptr, 
+                                 const char **keys, size_t *key_length, 
+                                 size_t number_of_keys);
+ 
+ LIBMEMCACHED_API
++memcached_return memcached_mget_len(memcached_st *ptr, 
++                                    const char **keys, size_t *key_length, 
++                                    size_t number_of_keys, uint32_t user_spec_len);
++
++LIBMEMCACHED_API
+ char *memcached_get_by_key(memcached_st *ptr, 
+-                           const char *master_key, size_t master_key_length, 
+-                           const char *key, size_t key_length, 
++                           const char *master_key, 
++                           size_t master_key_length, 
++                           const char *key, size_t key_length,
++                           uint32_t user_spec_len,
+                            size_t *value_length, 
+                            uint32_t *flags,
+                            memcached_return *error);
+@@ -40,7 +58,8 @@ memcached_return memcached_mget_by_key(memcached_st *ptr,
+                                        master_key_length,
+                                        const char **keys, 
+                                        size_t *key_length, 
+-                                       size_t number_of_keys);
++                                       size_t number_of_keys,
++                                       uint32_t user_spec_len);
+ 
+ LIBMEMCACHED_API
+ char *memcached_fetch(memcached_st *ptr, 
+diff --git a/tests/function.c b/tests/function.c
+--- a/libmemcached-0.32/tests/function.c
++++ b/tests/function.c
+@@ -291,9 +291,10 @@ static test_return  error_test(memcached_st *memc)
+                         334139633U, 2257084983U, 3088286104U, 13199785U, 2542027183U, 1097051614U, 199566778U, 2748246961U, 2465192557U, 
+                         1664094137U, 2405439045U, 1842224848U, 692413798U, 3479807801U, 919913813U, 4269430871U, 610793021U, 527273862U, 
+                         1437122909U, 2300930706U, 2943759320U, 674306647U, 2400528935U, 54481931U, 4186304426U, 1741088401U, 2979625118U, 
+-                        4159057246U, 1769812374U, 2302537950U, 1110330676U };
++                        4159057246U, 1769812374U, 2302537950U, 1110330676U};
+ 
+-  assert(MEMCACHED_MAXIMUM_RETURN == 40); // You have updated the memcache_error messages but not updated docs/tests.
++  // You have updated the memcache_error messages but not updated docs/tests.
++  assert(MEMCACHED_SUCCESS == 0 && MEMCACHED_MAXIMUM_RETURN == 40);
+   for (rc= MEMCACHED_SUCCESS; rc < MEMCACHED_MAXIMUM_RETURN; rc++)
+   {
+     uint32_t hash_val;
+@@ -505,6 +506,170 @@ static test_return  cas_test(memcached_st *memc)
+   return 0;
+ }
+ 
++static test_return  mget_len_no_cas_test(memcached_st *memc)
++{
++  unsigned int x;
++  memcached_return rc;
++  uint32_t number_of_keys = 3;
++  const char *keys[]= {"fudge_for_me", "son_of_bonnie", "food_a_la_carte"};
++  size_t keys_length[]= {12, 13, 15};
++  const unsigned int specified_length = 4;
++
++  memcached_result_st results_obj;
++  memcached_result_st *results;
++
++  results= memcached_result_create(memc, &results_obj);
++  assert(results);
++  assert(&results_obj == results);
++
++  /* We need to empty the server before continuing test */
++  rc= memcached_flush(memc, 0);
++  assert(rc == MEMCACHED_SUCCESS);
++
++  rc= memcached_mget(memc, keys, keys_length, number_of_keys);
++  assert(rc == MEMCACHED_SUCCESS);
++
++  while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
++  {
++    assert(results);
++  }
++
++  while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
++  assert(!results);
++  assert(rc == MEMCACHED_END);
++
++  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 0);
++
++  for (x= 0; x < number_of_keys; x++)
++  {
++    rc= memcached_set(memc, keys[x], keys_length[x], 
++                      keys[x], keys_length[x],
++                      (time_t)50, (uint32_t)9);
++    assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
++  }
++
++  rc= memcached_mget_len(memc, keys, keys_length, number_of_keys, specified_length);
++
++  if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1)  {
++    assert(rc == MEMCACHED_NOT_SUPPORTED);
++    return 0;
++  }
++
++  assert(rc == MEMCACHED_SUCCESS);
++
++  x = 0;
++  while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
++  {
++    assert(results);
++    assert(&results_obj == results);
++    assert(rc == MEMCACHED_SUCCESS);
++    assert(!memcached_result_cas(results));
++    
++    char *result_str = memcached_result_value(results);
++    assert(strlen(result_str) == specified_length);
++
++    x++;
++  }
++  assert(x == number_of_keys);
++
++  memcached_result_free(&results_obj);
++
++  return 0;
++}
++
++static test_return  mget_len_cas_test(memcached_st *memc)
++{
++  unsigned int x;
++  memcached_return rc;
++  uint32_t number_of_keys = 3;
++  const char *keys[]= {"fudge_for_me", "son_of_bonnie", "food_a_la_carte"};
++  size_t keys_length[]= {12, 13, 15};
++  const unsigned int specified_length = 4;
++  const char *value2= "change the value";
++  size_t value2_length= strlen(value2);
++
++  memcached_result_st results_obj;
++  memcached_result_st *results;
++
++  results= memcached_result_create(memc, &results_obj);
++  assert(results);
++  assert(&results_obj == results);
++
++  /* We need to empty the server before continuing test */
++  rc= memcached_flush(memc, 0);
++  assert(rc == MEMCACHED_SUCCESS);
++
++  rc= memcached_mget(memc, keys, keys_length, number_of_keys);
++  assert(rc == MEMCACHED_SUCCESS);
++
++  while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
++  {
++    assert(results);
++  }
++
++  while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
++  assert(!results);
++  assert(rc == MEMCACHED_END);
++
++  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1);
++
++  for (x= 0; x < number_of_keys; x++)
++  {
++    rc= memcached_set(memc, keys[x], keys_length[x], 
++                      keys[x], keys_length[x],
++                      (time_t)50, (uint32_t)9);
++    assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
++  }
++
++  rc= memcached_mget_len(memc, keys, keys_length, number_of_keys, specified_length);
++
++  if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1)  {
++    assert(rc == MEMCACHED_NOT_SUPPORTED);
++    return 0;
++  }
++
++  assert(rc == MEMCACHED_SUCCESS);
++
++  /*
++   * memcached_cas() calls below truncate memcached_fetch_result()'s
++   * results so clone the memcached_st state and move on with life.
++   * This happens when using memcached_mget() and memcached_mget_len().
++   */
++  memcached_st *mclone= memcached_clone(NULL, memc);
++
++  x = 0;
++  while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
++  {
++    assert(results);
++    assert(&results_obj == results);
++    assert(rc == MEMCACHED_SUCCESS);
++    
++    char *result_str = memcached_result_value(results);
++    assert(strlen(result_str) == specified_length);
++
++    assert(memcached_result_cas(results));
++
++    uint64_t cas = memcached_result_cas(results);
++    char *key = memcached_result_key_value(results);
++    uint32_t key_length = memcached_result_key_length(results);
++    rc= memcached_cas(mclone, key, key_length, value2, value2_length, 0, 0, cas);
++
++    /*
++     * The item will have a new cas value, so try to set it again with the old
++     * value. This should fail!
++     */
++    rc= memcached_cas(mclone, key, key_length, value2, value2_length, 0, 0, cas);
++    assert(rc == MEMCACHED_DATA_EXISTS);
++
++    x++;
++  }
++  assert(x == number_of_keys);
++
++  memcached_result_free(&results_obj);
++
++  return 0;
++}
++
+ static test_return  prepend_test(memcached_st *memc)
+ {
+   memcached_return rc;
+@@ -706,7 +871,8 @@ static test_return  bad_key_test(memcached_st *memc)
+     rc= memcached_mget(memc_clone, keys, key_lengths, 3);
+     assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
+ 
+-    rc= memcached_mget_by_key(memc_clone, "foo daddy", 9, keys, key_lengths, 1);
++    rc= memcached_mget_by_key(memc_clone, "foo daddy", 9, keys, key_lengths,
++                              1, GET_LEN_ARG_UNSPECIFIED);
+     assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
+ 
+     max_keylen= 250;
+@@ -872,6 +1038,100 @@ static test_return  get_test2(memcached_st *memc)
+   return 0;
+ }
+ 
++static test_return  get_len_test(memcached_st *memc)
++{
++  memcached_return rc;
++  const char *key= "foo_never_found_thank_you";
++  const uint32_t user_spec_len = 4;
++  char *string;
++  size_t string_length;
++  uint32_t flags;
++
++  rc= memcached_delete(memc, key, strlen(key), (time_t)0);
++  assert(rc == MEMCACHED_BUFFERED || rc == MEMCACHED_NOTFOUND);
++
++  string= memcached_get_len(memc, key, strlen(key), user_spec_len,
++                            &string_length, &flags, &rc);
++
++  if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1)  {
++    assert(rc == MEMCACHED_NOT_SUPPORTED);
++  } else {
++    assert(rc == MEMCACHED_NOTFOUND);
++    assert(string_length ==  0);
++    assert(!string);
++  }
++
++  return 0;
++}
++
++static test_return  get_len_test2(memcached_st *memc)
++{
++  memcached_return rc;
++  const char *key= "foo";
++  const char *value= "when we sanitize";
++  const uint32_t user_spec_len = 6;
++  const char *ret_value= "when w";
++  char *string;
++  size_t string_length;
++  uint32_t flags;
++
++  rc= memcached_set(memc, key, strlen(key), 
++                    value, strlen(value),
++                    (time_t)0, (uint32_t)0);
++  assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
++
++  string= memcached_get_len(memc, key, strlen(key), user_spec_len,
++                            &string_length, &flags, &rc);
++
++  if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1)  {
++    assert(rc == MEMCACHED_NOT_SUPPORTED);
++  } else {
++    assert(string);
++    assert(rc == MEMCACHED_SUCCESS);
++    assert(string_length == strlen(ret_value));
++    assert(!memcmp(string, ret_value, string_length));
++
++    free(string);
++  }
++
++  return 0;
++}
++
++static test_return  get_len_test3(memcached_st *memc)
++{
++  memcached_return rc;
++  const char *key= "test";
++  const char *value= "bar";
++  const uint32_t user_spec_len = 2;
++  const char *ret_value= "ba";
++  char *string;
++  size_t string_length;
++  uint32_t flags;
++
++  rc= memcached_set(memc, key, strlen(key), 
++                    value, strlen(value),
++                    (time_t)0, (uint32_t)0);
++  assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
++
++  string= memcached_get_len(memc, key, strlen(key), user_spec_len,
++                            &string_length, &flags, &rc);
++
++  if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1)  {
++    assert(rc == MEMCACHED_NOT_SUPPORTED);
++  } else {
++    assert(string);
++    assert(rc == MEMCACHED_SUCCESS);
++    assert(string_length == strlen(ret_value));
++    assert(!memcmp(string, ret_value, string_length));
++
++    free(string);
++  }
++
++  return 0;
++}
++
++
++
+ static test_return  set_test2(memcached_st *memc)
+ {
+   memcached_return rc;
+@@ -1031,6 +1291,7 @@ static test_return get_test5(memcached_st *memc)
+   assert(rc == MEMCACHED_SUCCESS);
+ 
+   char *val= memcached_get_by_key(memc, keys[0], lengths[0], "yek", 3,
++                                  GET_LEN_ARG_UNSPECIFIED,
+                                   &rlen, &flags, &rc);
+   assert(val == NULL);
+   assert(rc == MEMCACHED_NOTFOUND);
+@@ -1225,6 +1486,80 @@ static test_return  mget_result_test(memcached_st *memc)
+   return 0;
+ }
+ 
++static test_return  mget_len_result_test(memcached_st *memc)
++{
++  memcached_return rc;
++  uint32_t number_of_keys = 3;
++  const char *keys[]= {"fudge_for_me", "son_of_bonnie", "food_a_la_carte"};
++  size_t key_length[]= {12, 13, 15};
++  const unsigned int specified_length = 4;
++  const char *expected_results[]= {"fudg", "son_", "food"};
++  unsigned int x;
++
++  memcached_result_st results_obj;
++  memcached_result_st *results;
++
++  results= memcached_result_create(memc, &results_obj);
++  assert(results);
++  assert(&results_obj == results);
++
++  /* We need to empty the server before continueing test */
++  rc= memcached_flush(memc, 0);
++  assert(rc == MEMCACHED_SUCCESS);
++
++  rc= memcached_mget(memc, keys, key_length, number_of_keys);
++  assert(rc == MEMCACHED_SUCCESS);
++
++  while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
++  {
++    assert(results);
++  }
++
++  while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
++  assert(!results);
++  assert(rc == MEMCACHED_END);
++
++  for (x= 0; x < number_of_keys; x++)
++  {
++    rc= memcached_set(memc, keys[x], key_length[x], 
++                      keys[x], key_length[x],
++                      (time_t)50, (uint32_t)9);
++    assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
++  }
++
++  rc= memcached_mget_len(memc, keys, key_length, number_of_keys, specified_length);
++
++  if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1)  {
++    assert(rc == MEMCACHED_NOT_SUPPORTED);
++    return 0;
++  }
++
++  assert(rc == MEMCACHED_SUCCESS);
++
++  x = 0;
++  while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
++  {
++    char *result_str = memcached_result_value(results);
++    size_t str_len = strlen(result_str);
++    assert(results);
++    assert(&results_obj == results);
++    assert(rc == MEMCACHED_SUCCESS);
++    assert(str_len == specified_length);
++    assert(strlen(expected_results[0]) == specified_length);
++    assert(strlen(expected_results[1]) == specified_length);
++    assert(strlen(expected_results[2]) == specified_length);
++    assert((memcmp(result_str, expected_results[0], specified_length) == 0) ||
++           (memcmp(result_str, expected_results[1], specified_length) == 0) ||
++           (memcmp(result_str, expected_results[2], specified_length) == 0));
++    x++;
++  }
++  assert(x == number_of_keys);
++
++  memcached_result_free(&results_obj);
++
++  return 0;
++}
++
+ static test_return  mget_result_alloc_test(memcached_st *memc)
+ {
+   memcached_return rc;
+@@ -3633,6 +3968,7 @@ static test_return replication_set_test(memcached_st *memc)
+     size_t len;
+     uint32_t flags;
+     char *val= memcached_get_by_key(memc_clone, key, 1, "bubba", 5, 
++                                    GET_LEN_ARG_UNSPECIFIED,
+                                     &len, &flags, &rc);
+     assert(rc == MEMCACHED_SUCCESS);
+     assert(val != NULL);
+@@ -3664,6 +4000,7 @@ static test_return replication_get_test(memcached_st *memc)
+       size_t len;
+       uint32_t flags;
+       char *val= memcached_get_by_key(memc_clone, key, 1, "bubba", 5, 
++                                      GET_LEN_ARG_UNSPECIFIED,
+                                       &len, &flags, &rc);
+       assert(rc == MEMCACHED_SUCCESS);
+       assert(val != NULL);
+@@ -3721,7 +4058,8 @@ static test_return replication_mget_test(memcached_st *memc)
+     {
+       const char key[2]= { [0]= (const char)x };
+ 
+-      rc= memcached_mget_by_key(new_clone, key, 1, keys, len, 4);
++      rc= memcached_mget_by_key(new_clone, key, 1, keys, len,
++                                4, GET_LEN_ARG_UNSPECIFIED);
+       assert(rc == MEMCACHED_SUCCESS);
+ 
+       memcached_result_st *results= memcached_result_create(new_clone, &result_obj);
+@@ -3782,7 +4120,8 @@ static test_return replication_delete_test(memcached_st *memc)
+     {
+       const char key[2]= { [0]= (const char)x };
+ 
+-      rc= memcached_mget_by_key(memc_clone, key, 1, keys, len, 4);
++      rc= memcached_mget_by_key(memc_clone, key, 1, keys, len,
++                                4, GET_LEN_ARG_UNSPECIFIED);
+       assert(rc == MEMCACHED_SUCCESS);
+ 
+       memcached_result_st *results= memcached_result_create(memc_clone, &result_obj);
+@@ -4437,6 +4776,9 @@ test_st tests[] ={
+   {"get3", 0, get_test3 },
+   {"get4", 0, get_test4 },
+   {"partial mget", 0, get_test5 },
++  {"get_len", 1, get_len_test }, 
++  {"get_len2", 0, get_len_test2 },
++  {"get_len3", 0, get_len_test3 },
+   {"stats_servername", 0, stats_servername_test },
+   {"increment", 0, increment_test },
+   {"increment_with_initial", 1, increment_with_initial_test },
+@@ -4445,6 +4787,7 @@ test_st tests[] ={
+   {"quit", 0, quit_test },
+   {"mget", 1, mget_test },
+   {"mget_result", 1, mget_result_test },
++  {"mget_len_result", 1, mget_len_result_test },
+   {"mget_result_alloc", 1, mget_result_alloc_test },
+   {"mget_result_function", 1, mget_result_function },
+   {"get_stats", 0, get_stats },
+@@ -4492,6 +4835,8 @@ test_st version_1_2_3[] ={
+   {"prepend", 0, prepend_test },
+   {"cas", 0, cas_test },
+   {"cas2", 0, cas2_test },
++  {"mget_len_no_cas", 0, mget_len_no_cas_test },
++  {"mget_len_cas", 0, mget_len_cas_test },
+   {"append_binary", 0, append_binary_test },
+   {0, 0, 0}
+ };